java自定义类加载器

前言

　　java反射，最常用的Class.forName()方法。做毕设的时候，接收到代码字符串，通过 JavaCompiler将代码字符串生成A.class文件（存放在classpath下，也就是eclipse项目中的bin目录里），然后通过java反射机制，获取main方法并执行。.class文件名称固定。当 A.class文件更新的时候，问题出现了，main方法的执行结果总和第一次的执行结果相同。

程序流程

　　代码提交->接收代码->编译成A.class文件->java反射->main方法执行

　　具体代码参考：http://www.cnblogs.com/hujunzheng/p/5203067.html

问题原因

　　类加载器的委托机制！说到这里，不得不介绍一下java的类加载器。

java虚拟机中的类加载器

　　java虚拟机中可以安装多个类加载器，系统默认三个主要的类加载器，每个类负责加载特定位置的类： BootStrap,ExtClassLoader,AppClassLoader

　　类加载器也是Java类，因为Java类的类加载器本身也是要被类加载器加载的，显然必须有第一个类加载器不是Java类，这个正是BootStrap,使用C/C++代码写的，已经封装到JVM内核中了，而ExtClassLoader和AppClassLoader是Java类。

类加载器的属性结构图

　　盗图一张：

由此得到结论

　　首先我的A.class文件更新了，接着调用Class.forName()[我想的是重新加载一下字节码文件对象]，然后最终由AppClassLoader去加载，其中有一个函数很重要，就是loadClass(), 看一下这个函数的源码，如下：

protected Class<?> loadClass(String name, boolean resolve)throws ClassNotFoundException{  
 //加上锁，同步处理，因为可能是多线程在加载类  
 synchronized (getClassLoadingLock(name)) {  
     //检查，是否该类已经加载过了，如果加载过了，就不加载了  
     Class c = findLoadedClass(name);  
     if (c == null) {  
         long t0 = System.nanoTime();  
         try {  
             //如果自定义的类加载器的parent不为null,就调用parent的loadClass进行加载类  
             if (parent != null) {  
                 c = parent.loadClass(name, false);  
             } else {  
                 //如果自定义的类加载器的parent为null，就调用findBootstrapClass方法查找类，就是Bootstrap类加载器  
                 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();  
             //如果parent加载类失败，就调用自己的findClass方法进行类加载  
             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;  
 }  
}  

　　如果同名的.class文件之前加载了就不会在加载了。。。

解决办法　　用户自定义类加载器

　　想法1： 重写loadClass（）这个函数，无论是否加载过.class问价，都重新加载。

　　 @Override
    public java.lang.Class<?> loadClass(String name) throws ClassNotFoundException {
        System.out.println(name);
        byte[] data = loaderClassData(name);
        return this.defineClass(name, data, 0, data.length);
    };

　　但是竟然出错了，至今还没有搞明白... Main是我要加载的类，loadClass()函数执行了两次，第二次不知道怎么调用的。。。？有谁知到，告诉我一下，谢了！

Main
java.lang.Object
java.io.FileNotFoundException: java\lang\Object.class (系统找不到指定的路径。)
    at java.io.FileInputStream.open(Native Method)
    at java.io.FileInputStream.<init>(Unknown Source)
    at com.ds.tools.MyClassLoader.loaderClassData(MyClassLoader.java:53)
    at com.ds.tools.MyClassLoader.loadClass(MyClassLoader.java:78)
    at java.lang.ClassLoader.defineClass1(Native Method)
    at java.lang.ClassLoader.defineClassCond(Unknown Source)
    at java.lang.ClassLoader.defineClass(Unknown Source)
    at java.lang.ClassLoader.defineClass(Unknown Source)
    at com.ds.tools.MyClassLoader.loadClass(MyClassLoader.java:79)
    at com.ds.tools.MyClassLoader.main(MyClassLoader.java:96)

　　想法2： 只能默默的重写findClass()方法了， loadClass()方法中会调用这个函数，为了避过AppClassLoader检查类是否已经加载过了，我把A.class的生成位置放到了项目根目录下的myClass目录中，这样MyClassLoader委托AppClassLoader对A.class进行加载时，在当前的classpath下找不到对应的类，无法完成类的加载（同样BootStrapLoader和ExtClassLoader都不会找到），最终是我们自定的类加载器完成类的加载，代码如下：

public class MyClassLoader extends ClassLoader {
    //类加载器名称
    private String loaderName;
    //加载类的路径
    private String path = "";
    private final String fileType = ".class";
    public MyClassLoader(String loaderName){
        //让系统类加载器成为该 类加载器的父加载器
        super();
        this.loaderName = loaderName;
    }

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

    public String getPath() {
        return path;
    }

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

    @Override
    public String toString() {
        return this.loaderName;
    }

    /**
     * 获取.class文件的字节数组
     * @param name
     * @return
     */
    private byte[] loaderClassData(String name){
        InputStream is = null;
        byte[] data = null;
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        name = name.replace(".", "/");
        try {
            is = new FileInputStream(new File(path + name + fileType));
            int c = 0;
            while(-1 != (c = is.read())){
                baos.write(c);
            }
            data = baos.toByteArray();

        } catch (Exception e) {
            e.printStackTrace();
        } finally{
            try {
                if(is != null)
                    is.close();
                if(baos != null)
                    baos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return data;
    }
    
    /**
     * 获取Class对象
     */
    @Override
    public Class<?> findClass(String name) throws ClassNotFoundException{
        byte[] data = loaderClassData(name);
        return this.defineClass(name, data, 0, data.length);
    }

    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, SecurityException, NoSuchMethodException, IllegalArgumentException, InvocationTargetException {
        for(int i=0; i<5; i++){
            MyClassLoader loader1 = new MyClassLoader("MyClassLoader");
            //String path = new File(MyClassLoader.getSystemClassLoader().getResource("").getPath()).getParent();
            loader1.setPath("myClass/");
            Class<?> clazz = loader1.loadClass("Main");
            System.out.println(clazz.getName());
        }
    }
}