自定义类加载器

一：ClassLoader类加载器，主要的作用是将class文件加载到jvm虚拟机中。jvm启动的时候，并不是一次性加载所有的类，而是根据需要动态去加载类，主要分为隐式加载和显示加载。

　　隐式加载：程序代码中不通过调用ClassLoader来加载需要的类，而是通过JVM类自动加载需要的类到内存中。例如，当我们在类中继承或者引用某个类的时候，JVM在解析当前这个类的时，发现引用的类不在内存中，那么就会自动将这些类加载到内存中。

　　显示加载：代码中通过Class.forName（），this.getClass.getClassLoader.LoadClass（），自定义类加载器中的findClass（）方法等。

　　二：jvm自带的加载器

　　（1）BootStrap ClassLoader：主要加载%JRE_HOME%\lib下的rt.jar、resources.jar、charsets.jar和class等。可以通System.getProperty("sun.boot.class.path")

　　　　 查看加载的路径，如下：

package test;

public class TestGC {
    
    public static void main(String []args){

        System.out.println(System.getProperty("sun.boot.class.path"));
        
    }
}

　　　　显示结果如下：

D:\Program Files\Java\jdk1.7.0_45\jre\lib\resources.jar;D:\Program Files\Java\jdk1.7.0_45\jre\lib\rt.jar;D:\Program Files\Java\jdk1.7.0_45\jre\lib\sunrsasign.jar;D:\Program Files\Java\jdk1.7.0_45\jre\lib\jsse.jar;D:\Program Files\Java\jdk1.7.0_45\jre\lib\jce.jar;D:\Program Files\Java\jdk1.7.0_45\jre\lib\charsets.jar;D:\Program Files\Java\jdk1.7.0_45\jre\lib\jfr.jar;D:\Program Files\Java\jdk1.7.0_45\jre\classes

　　（2）Extention ClassLoader：主要加载目录%JRE_HOME%\lib\ext目录下的jar包和class文件。也可以通过System.out.println(System.getProperty("java.ext.dirs"))查看加载类文件的路径。

　　（3）AppClassLoader：主要加载当前应用下的classpath路径下的类。之前我们在环境变量中配置的classpath就是指定AppClassLoader的类加载路径。

　　三：类加载器的继承关系

　　先看一下这三个类加载器之间的继承关系，如下图：

　　

　　ExtClassLoader，AppClassLoder继承URLClassLoader，而URLClassLoader继承ClassLoader，BoopStrap ClassLoder不在上图中，因为它是由C/C++编写的，它本身是虚拟机的一部分，并不是一个java类。jvm加载的顺序：BoopStrap ClassLoder-〉ExtClassLoader->AppClassLoder，下面看一段源码：

public class Launcher {
    private static Launcher launcher = new Launcher();
    private static String bootClassPath =
        System.getProperty("sun.boot.class.path");

    public static Launcher getLauncher() {
        return launcher;
    }

    private ClassLoader loader;

    public Launcher() {
        // Create the extension class loader
        ClassLoader extcl;
        try {
            extcl = ExtClassLoader.getExtClassLoader();
        } catch (IOException e) {
            throw new InternalError(
                "Could not create extension class loader", e);
        }

        // Now create the class loader to use to launch the application
        try {
            loader = AppClassLoader.getAppClassLoader(extcl);
        } catch (IOException e) {
            throw new InternalError(
                "Could not create application class loader", e);
        }

        Thread.currentThread().setContextClassLoader(loader);
    }

    /*
     * Returns the class loader used to launch the main application.
     */
    public ClassLoader getClassLoader() {
        return loader;
    }
    /*
     * The class loader used for loading installed extensions.
     */
    static class ExtClassLoader extends URLClassLoader {}

/**
     * The class loader used for loading from java.class.path.
     * runs in a restricted security context.
     */
    static class AppClassLoader extends URLClassLoader {}

　　　从源码中我们看到：（1）Launcher初始化的时候创建了ExtClassLoader以及AppClassLoader，并将ExtClassLoader实例传入到AppClassLoader中。

　　　（2）虽然上一段源码中没见到创建BoopStrap ClassLoader，但是程序一开始就执行了System.getProperty("sun.boot.class.path")。

　　四：类加载器之间的父子关系

　　　　AppClassLoader的父加载器为ExtClassLoader，ExtClassLoader的父加载器为null，BoopStrap ClassLoader为顶级加载器。

　

在自定义类加载器之前，首先来看看jdk中的ClassLoader是怎么实现的

public Class<?> loadClass(String name) throws ClassNotFoundException {
        return loadClass(name, false);
    }

继续跟

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

源码中可以看到，首先尝试自己加载 findLoadedClass(name); 如果为空，就丢给父类加载器加载，加载成功就返回一个java.lang.class,加在不成功就执行findclass(name)方法。

看一下findClass方法是怎么实现的

 /**
     * Finds the class with the specified <a href="#name">binary name</a>.
     * This method should be overridden by class loader implementations that
     * follow the delegation model for loading classes, and will be invoked by
     * the {@link #loadClass <tt>loadClass</tt>} method after checking the
     * parent class loader for the requested class.  The default implementation
     * throws a <tt>ClassNotFoundException</tt>.
     */
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        throw new ClassNotFoundException(name);
    }

是的，这个方法只是抛出了一个异常。从注释中我们知道，这个方法是坐着希望要被重写的方法。很明显，如果我们要自定义加载器的话，只需要重写findClass这个方法就好了（因为如果重写整个loadClass方法，会破坏双亲委托机制）

首先 用记事本编写一个Person类

   public class Person
  {
      private String name;
      
      public Person()
      {
          
     }
     
     public Person(String name)
     {
         this.name = name;
     }
     
     public String getName()
     {
         return name;
     }
     
     public void setName(String name)
     {
         this.name = name;
     }
     
     public String toString()
     {
         return "I am a person, my name is " + name;
     }
 }

然后cmd把改类编译为class文件，放在E盘根目录下

接下来创建MyClassLoader类，继承ClassLoader,重写findClass方法。

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.nio.ByteBuffer;
import java.nio.channels.Channels;
import java.nio.channels.FileChannel;
import java.nio.channels.WritableByteChannel;

public class MyClassLoader extends ClassLoader{
	 private String classpath;
	public MyClassLoader()
    {
        
    }
    
    public MyClassLoader(String classpath)
    {
    	 this.classpath = classpath;
    }
    
    protected Class<?> findClass(String name) throws ClassNotFoundException
    {
        try
        {
            byte[] bytes = getData(name);
            Class<?> c = this.defineClass(name, bytes, 0, bytes.length);
            return c;
        } 
        catch (Exception e)
        {
            e.printStackTrace();
        }
        
        return super.findClass(name);
    }
    
  //返回类的字节码
    private byte[] getData(String className) throws IOException{
        InputStream in = null;
        ByteArrayOutputStream out = null;
        String path=classpath + File.separatorChar +
                    className.replace('.',File.separatorChar)+".class";
        try {
            in=new FileInputStream(path);
            out=new ByteArrayOutputStream();
            byte[] buffer=new byte[2048];
            int len=0;
            while((len=in.read(buffer))!=-1){
                out.write(buffer,0,len);
            }
            return out.toByteArray();
        } 
        catch (FileNotFoundException e) {
            e.printStackTrace();
        }
        finally{
            in.close();
            out.close();
        }
        return null;
    }
    
    public static void main(String[] args) {
		try {
			MyClassLoader mcl = new MyClassLoader("E:\\");
			Class c = mcl.loadClass("Person");
			Object obj = c.newInstance();
			System.out.println(obj);
			System.out.println(obj.getClass().getClassLoader());
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

最后运行