`
javatgo
  • 浏览: 1169351 次
  • 性别: Icon_minigender_2
  • 来自: 北京
文章分类
社区版块
存档分类
最新评论

ClassLoader编程实践

 
阅读更多

java1.1中的实现


java1.1的类加载机制相对单一，而用户自定义加载器的重写却比较复杂。。

主要需要重写ClassLoader中一个方法：Class loadClass(String name)。

Class loadClass(String name)：loadClass(String name)(或者loadClass(String name , boolean resolve))这个方法是加载的核心，他将根据类名（全名，比如java.lang.String）获得对应类的二进制数据，然后通过Class defineClass(byte[] b)将二进制数据加载到JVM的方法区，defineClass返回对应类的Class 实例，并根据可选的参数resolve决定是否需要现在解析这个类，之后将这个Class实例作为 loadClass方法的返回值。

其中，若是没有办法实现加载和defineClass,即无法通过本加载器直接加载类的情况，则使用Class findSystemClass(String name)委派系统的加载器查找，如果能找到则加载，否则，抛出ClassNotFoundException。可见，这个方法必须放在 loadClass方法中自定义加载的代码之后。

重写loadClass方法还是相对复杂的，需要考虑到各种加载情况。


以下的例子实现了这一过程。

它是一个能直接由.java源文件实现类加载的 加载器：CompilingClassLoader。

就像之前说到的，只需要重写loadClass()方法，用户自定义的加载实现逻辑都在这个方法中。至于代码中的其中的

其他的方法，比如defineClass(String name),findSystemClass(String name)都是由loadClass调用的。

CompilingClassLoader类中还包含了执行对去字节码、编译java文件的方法，都为loadClass()方法所用。

在defineClass()或findSystemClass()执行结束前，可能返回的异常挺多的：NoClassDefFoundError ,ClassNotFoundError , ClassFormatError , UnsupportedClassVersionError , LinkageError , ClassCircularityError , IncompatibleClassChangeError . 详细信息请大家查阅java doc。


代码如下：
CompilingClassLoader.java
import java.io.*;  
  1.   
  2. /* 
  3.  
  4. A CompilingClassLoader compiles your Java source on-the-fly.  It 
  5. checks for nonexistent .class files, or .class files that are older 
  6. than their corresponding source code. 
  7.  
  8. */  
  9.   
  10. public class CompilingClassLoader extends ClassLoader  
  11. {  
  12.   // Given a filename, read the entirety of that file from disk   
  13.   // and return it as a byte array.   
  14.   private byte[] getBytes( String filename ) throws IOException {  
  15.     // Find out the length of the file   
  16.     File file = new File( filename );  
  17.     long len = file.length();  
  18.   
  19.     // Create an array that's just the right size for the file's   
  20.     // contents   
  21.     byte raw[] = new byte[(int)len];  
  22.   
  23.     // Open the file   
  24.     FileInputStream fin = new FileInputStream( file );  
  25.   
  26.     // Read all of it into the array; if we don't get all,   
  27.     // then it's an error.   
  28.     int r = fin.read( raw );  
  29.     if (r != len)  
  30.       throw new IOException( "Can't read all, "+r+" != "+len );  
  31.   
  32.     // Don't forget to close the file!   
  33.     fin.close();  
  34.   
  35.     // And finally return the file contents as an array   
  36.     return raw;  
  37.   }  
  38.   
  39.   // Spawn a process to compile the java source code file   
  40.   // specified in the 'javaFile' parameter.  Return a true if   
  41.   // the compilation worked, false otherwise.   
  42.   private boolean compile( String javaFile ) throws IOException {  
  43.     // Let the user know what's going on   
  44.     System.out.println( "CCL: Compiling "+javaFile+"..." );  
  45.   
  46.     // Start up the compiler   
  47.     Process p = Runtime.getRuntime().exec( "javac "+javaFile );  
  48.   
  49.     // Wait for it to finish running   
  50.     try {  
  51.       p.waitFor();  
  52.     } catch( InterruptedException ie ) { System.out.println( ie ); }  
  53.   
  54.     // Check the return code, in case of a compilation error   
  55.     int ret = p.exitValue();  
  56.   
  57.     // Tell whether the compilation worked   
  58.     return ret==0;  
  59.   }  
  60.   
  61.   // The heart of the ClassLoader -- automatically compile   
  62.   // source as necessary when looking for class files   
  63.   public Class loadClass( String name, boolean resolve )  
  64.       throws ClassNotFoundException {  
  65.   
  66.     // Our goal is to get a Class object   
  67.     Class clas = null;  
  68.   
  69.     // First, see if we've already dealt with this one   
  70.     clas = findLoadedClass( name );  
  71.   
  72.     //System.out.println( "findLoadedClass: "+clas );   
  73.   
  74.     // Create a pathname from the class name   
  75.     // E.g. java.lang.Object => java/lang/Object   
  76.     String fileStub = name.replace( '.', '/' );  
  77.   
  78.     // Build objects pointing to the source code (.java) and object   
  79.     // code (.class)   
  80.     String javaFilename = fileStub+".java";  
  81.     String classFilename = fileStub+".class";  
  82.   
  83.     File javaFile = new File( javaFilename );  
  84.     File classFile = new File( classFilename );  
  85.   
  86.     //System.out.println( "j "+javaFile.lastModified()+" c "+   
  87.     //  classFile.lastModified() );   
  88.   
  89.     // First, see if we want to try compiling.  We do if (a) there   
  90.     // is source code, and either (b0) there is no object code,   
  91.     // or (b1) there is object code, but it's older than the source   
  92.     if (javaFile.exists() &&  
  93.          (!classFile.exists() ||  
  94.           javaFile.lastModified() > classFile.lastModified())) {  
  95.   
  96.       try {  
  97.         // Try to compile it.  If this doesn't work, then   
  98.         // we must declare failure.  (It's not good enough to use   
  99.         // and already-existing, but out-of-date, classfile)   
  100.         if (!compile( javaFilename ) || !classFile.exists()) {  
  101.           throw new ClassNotFoundException( "Compile failed: "+javaFilename );  
  102.         }  
  103.       } catch( IOException ie ) {  
  104.   
  105.         // Another place where we might come to if we fail   
  106.         // to compile   
  107.         throw new ClassNotFoundException( ie.toString() );  
  108.       }  
  109.     }  
  110.   
  111.     // Let's try to load up the raw bytes, assuming they were   
  112.     // properly compiled, or didn't need to be compiled   
  113.     try {  
  114.   
  115.       // read the bytes   
  116.       byte raw[] = getBytes( classFilename );  
  117.   
  118.       // try to turn them into a class   
  119.       clas = defineClass( name, raw, 0, raw.length );  
  120.     } catch( IOException ie ) {  
  121.       // This is not a failure!  If we reach here, it might   
  122.       // mean that we are dealing with a class in a library,   
  123.       // such as java.lang.Object   
  124.     }  
  125.   
  126.     //System.out.println( "defineClass: "+clas );   
  127.   
  128.     // Maybe the class is in a library -- try loading   
  129.     // the normal way   
  130.     if (clas==null) {  
  131.       clas = findSystemClass( name );  
  132.     }  
  133.   
  134.     //System.out.println( "findSystemClass: "+clas );   
  135.   
  136.     // Resolve the class, if any, but only if the "resolve"   
  137.     // flag is set to true   
  138.     if (resolve && clas != null)  
  139.       resolveClass( clas );  
  140.   
  141.     // If we still don't have a class, it's an error   
  142.     if (clas == null)  
  143.       throw new ClassNotFoundException( name );  
  144.   
  145.     // Otherwise, return the class   
  146.     return clas;  
  147.   }  
  1. <span style="font-size: 16px; ">import java.lang.reflect.*;  
  2.   
  3. /* 
  4.  
  5. CCLRun executes a Java program by loading it through a 
  6. CompilingClassLoader. 
  7.  
  8. */  
  9.   
  10. public class CCLRun  
  11. {  
  12.   static public void main( String args[] ) throws Exception {  
  13.   
  14.     // The first argument is the Java program (class) the user   
  15.     // wants to run   
  16.     String progClass = args[0];  
  17.   
  18.     // And the arguments to that program are just   
  19.     // arguments 1..n, so separate those out into   
  20.     // their own array   
  21.     String progArgs[] = new String[args.length-1];  
  22.     System.arraycopy( args, 1, progArgs, 0, progArgs.length );  
  23.   
  24.     // Create a CompilingClassLoader   
  25.     CompilingClassLoader ccl = new CompilingClassLoader();  
  26.   
  27.     // Load the main class through our CCL   
  28.     Class clas = ccl.loadClass( progClass );  
  29.   
  30.     // Use reflection to call its main() method, and to   
  31.     // pass the arguments in.   
  32.   
  33.     // Get a class representing the type of the main method's argument   
  34.     Class mainArgType[] = { (new String[0]).getClass() };  
  35.   
  36.     // Find the standard main method in the class   
  37.     Method main = clas.getMethod( "main", mainArgType );  
  38.   
  39.     // Create a list containing the arguments -- in this case,   
  40.     // an array of strings   
  41.     Object argsArray[] = { progArgs };  
  42.   
  43.     // Call the method   
  44.     main.invoke( null, argsArray );  
  45.   }  
  46. }
Foo.java
<span style="font-size: 16px; ">public class Foo  
  1. {  
  2.   static public void main( String args[] ) throws Exception {  
  3.     System.out.println( "foo! "+args[0]+" "+args[1] );  
  4.   }  
  5. }  
  1. java CCLRun Foo arg1 arg2  
  2. CCL: Compiling Foo.java...  
  3. foo! arg1 arg2  
具体参见资料

来自IBM DeveloperWorks ： Understanding the Java ClassLoader 

这是一篇2001年的文章，是早年java1.1的实现方式。如今的java已经改变了 很多，变得更加人性化，多功能化，鲁棒性也更强了。


java1.2以后的实现

具体参见资料

改版以后，ClassLoader实现了parent-child模型，更好的控制安全性方面的问题。

为了延续parent-first的模式，通常在继承ClassLoader时不用重写loadClass()方法，而是重写findClass()方法。
findClass() ： 方法中需要定义如何获取类的字节码，并使用defineClass()完成加载（仅仅加载，没有resolve等步骤）。
对应的有一个findLoadedClass() ，这个方法用来实现对查找当前加载器是否有加载某类。由于findClass是从原来的loadClass方法中抽离的代码，重写也简单很多，省去了开发者对流程控制的很多顾虑。

loadClass()：如果使用parent-first的加载模型，loadClass（）方法是不用重写的。它通过向父亲加载器迭代实现了parent-first的委托关系。每次加载一个类时，先调findLoadedClass()，如果没有找到，则调用父亲加载器的loadClass()，如果找到了就返回Class实例，没有找到则父亲加载器会产生一个ClassNotFoundException，捕捉到这个Exception后，加载器会自己调用findClass()尝试实现对类的加载。如果依然没有成功加载，则产生一个ClassNotFoundException.

控制流程如图：这里显示了一个类未能成功加载所要经历的流程。（来自参考资料http://stackoverflow.com/questions/3544614/how-is-the-control-flow-to-findclass-of）
      A.loadClass()  
  1.            |  
  2.        (not-found?) (by findLoadedClass)  
  3.            |  
  4.       B.loadClass()  
  5.            |  
  6.        (not found?) (by findLoadedClass)  
  7.            |  
  8. systemclassloader.loadClass  (Bs parent, also can be   
  9.            |                  called classpath classloader)  
  10.            |  
  11.        (not found?) (by findLoadedClass)  
  12.            |  
  13. ootstrap classloader.loadClass (the bootstrap classloader,   
  14.            |                   (this has no parent)  
  15.            |  
  16.        (not found?)  
  17.            |  
  18. systemclassloader.findClass  (on system classloader,   
  19.            |                   will try to "find" class in "classpath")  
  20.            |  
  21.        (not found?) ClassNotFoundException  
  22.            |  
  23.        B.findClass  
  24.            |  
  25.        (not found?) ClassNotFoundException  
  26.            |  
  27.        A.findClass  
  28.            |  
  29.         (not found?)  
  30.            |  
  31.    ClassNotFoundException  



注意，对于extensions class loader ，它的parent加载器是null，因为bootstrap加载器是本地实现的，并非java实现，于是，如何从extension 加载器向上回溯呢？答案如下：
try {  
  1.     if (parent != null) {  
  2.        c = parent.loadClass(name, false);  
  3.     } else {  
  4.        c = findBootstrapClassOrNull(name);  
  5.     }  
  6. } catch (ClassNotFoundException e) {  
  7.    // ClassNotFoundException thrown if class not found   
  8.      // from the non-null parent class loader   
  9. }  
这是 ClassLoader的源代码，对于 parent 为null的情况，会直接调用findBootstrapClassOrNull方法尝试用bootstrap加载器加载 。通过源代码，能够很好的理解这里的parent-child 模型了。

另注意 对于基于parent-child模型的类加载器实现，都需要定义一个以parent类加载器作为参数的构造函数，以指定父加载器。如果直接调用没有参数的构造函数，则默认制定的是systemclassloader作为parent。

以下为编程实例
下面的例子是我用来实现动态分析java类关系的加载器代码。具体方法是：调用ASM api ， 在加载器中加载类时，修改.class文件中的字节码，加入相应语句，让对象在创建或执行相应指令时，在trace文件中记录自己的行为。不过实现的方式不是重点，重点是使用了自定义的类加载器的实现！
在编码的过程中，我遇到的一个错误是，将需要使用自定义加载器加载的类文件直接放在了eclipse工程中的bin目录下。而这个目录是可以通过appclassloader即systemclassloader找到路径并加载的。根据parent-first的实现，这些类直接被systemclassloader加载了，也就绕过了自定义加载器的处理机制。修改过路径以后没有出现相应问题了。

ASMClassLoader.java
package biaobiaoqi.classLoader;  
  1. import java.io.*;  
  2.   
  3. import org.objectweb.asm.ClassReader;  
  4. import org.objectweb.asm.ClassWriter;  
  5.   
  6. import biaobiaoqi.asm.*;  
  7.   
  8.   
  9. public class ASMClassLoader extends ClassLoader  
  10. {  
  11.     String basePath ;  
  12.       
  13.     /**reference to System Classloader as the parent class loader 
  14.      * @param path <br> the path of .class files will be loaded 
  15.      */  
  16.     public ASMClassLoader(String path){  
  17.         basePath = path ;  
  18.     }  
  19.    
  20.     /** 
  21.      * reference to parent as it's parent classloader 
  22.      * @param path 
  23.      * @param parent 
  24.      */  
  25.     public ASMClassLoader(String path , ClassLoader parent){  
  26.         super(parent);  
  27.         basePath = path ;  
  28.     }  
  29.   
  30.     @Override  
  31.     public Class findClass(String name) throws ClassNotFoundException{  
  32.         System.out.println("findClass");  
  33.         byte[] raw;  
  34.         try {  
  35.             raw = getBytesFromBasePath( name );  
  36.         } catch (IOException e) {  
  37.             e.printStackTrace();  
  38.             throw new ClassNotFoundException();  
  39.         }  
  40.       
  41.         byte[] transformed = instrumentBtyeCode(raw);  
  42.         /* 
  43.         try{ 
  44.             FileOutputStream file = new FileOutputStream( "/home/biaobiaoqi/" +name.replace( '.', '/' )+".class"); 
  45.             file.write( transformed); 
  46.             file.close(); 
  47.         } 
  48.         catch (IOException e) { 
  49.             e.printStackTrace(); 
  50.         } 
  51.         */  
  52.         if (transformed == null){  
  53.             throw new ClassNotFoundException();  
  54.         }  
  55.         
  56.           
  57.         return defineClass(name, transformed, 0, transformed.length );  
  58.     }  
  59.     
  60.     private byte[] getBytesFromBasePath( String className ) throws IOException ,ClassNotFoundException{  
  61.         String fileStub = className.replace( '.', '/' );  
  62.         String classFileName = basePath +fileStub+".class";  
  63.         File file = new File( classFileName );  
  64.           
  65.         long len = file.length();  
  66.         byte raw[] = new byte[(int)len];  
  67.         FileInputStream fin = new FileInputStream( file );  
  68.           
  69.         int r = fin.read( raw );  
  70.         if (r != len)  
  71.             throw new IOException( "Can't read all, "+r+" != "+len );  
  72.           
  73.         fin.close();  
  74.         return raw;  
  75.     }  
  76.       
  77.     private byte[] instrumentBtyeCode(byte[] raw){  
  78.         ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_FRAMES);  
  79.         ASMClassAdapter mca = new ASMClassAdapter(cw);   
  80.         ClassReader cr = new ClassReader(raw);  
  81.         cr.accept(mca, 0);  
  82.         return cw.toByteArray();  
  83.     }     
  84.       
  85.     @Override  
  86.     public Class loadClass( String name, boolean resolve )  
  87.         throws ClassNotFoundException {  
  88.         System.out.println("loadClass_resolve");  
  89.           return super.loadClass(name ,resolve);  
  90.     }  
  91.       
  92.       
  93.     @Override  
  94.     public Class loadClass( String name )  
  95.         throws ClassNotFoundException {  
  96.         System.out.println("loadClass");  
  97.           return super.loadClass(name );  
  98.     }  
  99.       
  100. }  

温馨提示：不要把需要用自定义加载器加载的类文件直接放在system classloader能达到的路径下，否则，parent-first会帮你加载好那个类。特别是在用eclipse等IDE开发的时候。。这个bug让我花了很长时间。。

分享到：
| 进化中项目进展
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    Java ClassLoader定制实例

    在Java编程语言中，ClassLoader是一个至关重要的组成部分，它负责加载类到JVM（Java虚拟机）中。理解ClassLoader的工作原理以及如何定制它，对于深入学习Java的运行机制和进行高级应用开发具有重要意义。本篇文章将...

    ClassLoader 案例

    在Java编程语言中，ClassLoader是核心组件之一，它负责加载类到JVM（Java虚拟机）中。自定义ClassLoader允许开发者根据特定需求加载类，比如动态加载或更新类文件，这在某些高级应用场景中非常有用，如插件系统、热...

    ClassLoader的 一些测试

    在Java编程语言中，ClassLoader是一个至关重要的组成部分，它负责加载类到JVM（Java虚拟机）中执行。这篇测试主要探讨了ClassLoader的...通过测试和实践，我们可以更好地掌握ClassLoader的使用，提升Java编程的技能。

    ClassLoader原理

    在Java编程语言中，ClassLoader是核心组件之一，它负责加载类到JVM（Java虚拟机）中，使得程序能够执行。ClassLoader原理的理解对于深入学习Java和进行系统优化至关重要。这篇博文将带你深入了解ClassLoader的工作...

    定义ClassLoader调用外部jar包

    在Java编程环境中，ClassLoader是一个至关重要的组件，它负责加载类到Java虚拟机（JVM）中。当我们需要从外部jar包动态加载类时，自定义ClassLoader就显得尤为关键。这篇博文"定义ClassLoader调用外部jar包"探讨了...

    使用classloader动态加载Class

    在Java编程语言中，类加载器（ClassLoader）是运行时环境的核心组成部分，它负责将类的字节码从各种来源（如JAR文件、网络、内存等）加载到Java虚拟机（JVM）中，使得程序能够运行。本文将深入探讨“使用classloader...

    基于Java的多样化编程实践.zip

    基于Java的多样化编程实践 该项目是一个用于练习和展示Java各种库和框架的实践项目，使用Maven构建。涵盖了从消息服务、切面编程、AI平台SDK到设计模式、Spring框架等多个方面的实现。 主要功能模块 消息服务 ...

    classloader源码

    在Java编程语言中，`ClassLoader`是一个至关重要的组件，它负责加载类到JVM（Java虚拟机）中。深入理解`ClassLoader`的源码对于Java开发者来说是提升技能的重要环节，尤其是在进行模块化、插件化开发或者进行系统...

    Understanding the Java ClassLoader

    #### 三、自定义ClassLoader实践 为了更深入地理解ClassLoader的工作机制，我们将构建一个简单的自定义ClassLoader示例，该ClassLoader能够在加载之前自动编译代码。 **1. 自定义ClassLoader的基本步骤** - **...

    ClassLoader总结

    在Java编程语言中，ClassLoader是核心组件之一，它负责加载类到JVM（Java虚拟机）中执行。这篇博文深入探讨了ClassLoader的工作原理及其在实际应用中的重要性。以下是ClassLoader的相关知识点： 1. 类加载机制： ...

    xwiki-commons-classloader-protocol-jar-5.4.zip

    《XWiki Commons Classloader Protocol Jar 5.4与LaZyWorker开源项目...这两个项目都体现了开源社区的创新精神和对软件性能优化的执着追求，对于学习和实践Java编程、类加载机制以及优化策略的开发者具有极高的价值。

    测试普通Java程序ClassLoader等级关系的Demo程序

    Java虚拟机（JVM）是Java程序运行的基础，它通过加载、验证、解析和执行字节码来实现程序的运行。在JVM中，类加载器（ClassLoader）扮演着至关重要的...通过实践和学习，我们能够提升Java编程的技能和解决问题的能力。

    classloader简单例子

    在Java编程语言中，类加载器（ClassLoader）是一个至关重要的组件，它负责将类的字节码加载到Java虚拟机（JVM）中，从而使程序能够运行。在这个简单的例子中，我们将探讨类加载器的基本概念、工作原理以及如何自定义...

    ClassLoaderDemo.7z

    在Java编程语言中，ClassLoader是核心的组成部分，它负责加载类到JVM（Java虚拟机）中。`ClassLoaderDemo.7z`这个压缩包提供的示例，旨在帮助我们理解ClassLoader的工作原理，特别是双亲委托模型以及如何打破这个...

    Java Classloading Mechanism : ClassLoader & ASM & 动态字节码增强

    - 在方法体中插入代码，实现AOP（面向切面编程）的动态代理。 ASM的使用通常涉及以下几个步骤： 1. 创建ClassWriter对象，它是字节码生成器，用于构建新的类或修改已有类。 2. 使用Visit接口访问类的结构，如类名、...

    JAVA工程师实习一周总结【推荐下载】.doc

    在实习期间，我尝试编写了自己的类加载器，这不仅加深了我对ClassLoader工作原理的理解，也锻炼了我的编程实践能力。这个过程让我认识到，作为一名JAVA工程师，不仅要掌握基本的语法和框架，还要理解JVM的底层运作，...

    classloader-example:博客帖子

    总的来说，这个“classloader-example”不仅是一个学习Java类加载器工作原理的好资源，也是一个实践自定义加载策略和运行时动态加载的实战案例。通过深入研究这个示例，开发者可以更好地掌握Java的高级特性，提高...

    java编程经验汇总

    在Java编程中，理解和掌握一些...在学习Java的过程中，实践是至关重要的，通过在命令行环境中编译和运行程序，可以加深对这些概念的理解。不断探索和实验，将有助于你在Java编程领域积累丰富的经验，避免不必要的弯路。

    JAVA的编程经验.pdf

    Java编程经验分享主要涵盖三个关键知识点：动态加载机制、类文件查找原理以及JDK与JRE的区别。 1. 动态加载机制： Java的动态加载机制是其面向对象特性的一个...通过实践和探索，可以更深刻地领会Java的魅力和灵活性。

    JAVA编程经验汇总.txt

    ### JAVA编程经验汇总 在Java开发领域，积累丰富的实践经验对于提升个人技能至关重要。本文将根据提供的文件信息，总结并深入探讨几个重要的Java编程知识点。 #### 1. Java与C++面向对象思想的区别 学习Java时，...

Magicbox
Global site tag (gtag.js) - Google Analytics