类加载器

  不论人生多不幸，聪明的人总会从中获得一点利益；不论人生多幸福，愚蠢的人总觉得无限悲哀。 —— 拉·罗休弗克

  通过一个类的全限定名来获取描述此类的二进制字节流这个动作放到Java虚拟机外部去实现，以便让应用程序自身决定如何获取所需要的类。实现这个动作的代码模块称为"类加载器"。

类与类加载器

  对于任意一个类，都需要由加载它的类加载器和这个类本身一同确立其在Java虚拟机中的唯一性。更通俗一点的说法：比较两个类是否"相等"，只有在这两个类是由同一个类加载器加载的前提下才有意义，否则，即使这两个类来源于同一个class文件，被同一个虚拟机加载，只要加载它们的类加载器不一样，那这两个类就必定不相等。

  这里的"相等"，包括代表类的Class对象的equals()方法、isAssignableForm()方法、isInstance()方法的返回结果，也包括使用instanceof关键字做对象所属关系判断等。

public class ClassLoaderTest {

    public static void main(String[] args) throws InstantiationException, IllegalAccessException, ClassNotFoundException {
        ClassLoader classLoader = new ClassLoader(){
            @Override
            public Class<?> loadClass(String name)
                    throws ClassNotFoundException {
                try {
                    String fileName = name.substring(name.lastIndexOf(".") + 1) + ".class";
                    InputStream is = getClass().getResourceAsStream(fileName);
                    if(null == is){
                        return super.loadClass(name);
                    }
                    byte[] b = new byte[is.available()];
                    is.read(b);
                    return defineClass(name, b, 0, b.length);
                } catch (IOException e) {
                    throw new ClassNotFoundException(name);
                }
            }
        };

        Object obj = classLoader.loadClass("com.xx.java.ClassLoaderTest").newInstance();
        System.out.println(obj.getClass());
        System.out.println(obj instanceof com.xx.java.ClassLoaderTest);
    }
}

运行结果：

class com.xx.java.ClassLoaderTest
false

  从运行结果来看，第一句返回的是class com.xx.java.ClassLoaderTest，说明这个对象确实是com.xx.java.ClassLoaderTest的实例化对象，而在用instanceof进行类所属关系判定时，返回的结果是false，这是因为虚拟机中存在了两个ClassLoaderTest，一个是由系统应用程序类加载器加载的，另外一个是由我们自定义的类加载器加载的，虽然来自于同一个class文件，但依然是两个独立的类。

双亲委派模型

  从Java虚拟机来讲，只存在两种类加载器，一种是启动类加载器（Bootstrap ClassLoader），另一种就是所有其他的类加载器，并且全部继承抽象类java.lang.ClassLoader。
  从Java开发人员来讲，类加载器可分为以下三种类加载器：

• 启动类加载器（Bootstrap ClassLoader）：该类加载器负责将存放在<JAVA_HOME>\lib目录中的，或者被-Xbootclasspath参数所指定的路径中的，并且可被虚拟机识别的类库加载到虚拟机。
• 扩展类加载器（Extension ClassLoader）：该类加载器由sun.misc.Launcher$ExtClassLoader实现，负责加载<JAVA_HOME>\lib\ext目录中的，或被java.ext.dirs系统变量所指定的路径中的所有类库。
• 应用程序类加载器（Application ClassLoader）：该类加载器由sun.misc.Launcher$AppClassLoader实现。负责加载Classpath上所指定的类。
• 自定义类加载器
    除了以上3种类加载器外，开发人员还可以自定义类加载器。实现自定义类加载有两种方式：重写ClassLoader类的findClass()方法或loadClass()方法。
• 重写loadClass()方法：
    如果要想在JVM的不同类加载器中保留具有相同全限定名的类，那就要通过重写loadClass来实现。实现方式是：首先通过用户自定义的类加载器来判断该类是否可加载，如果可以加载就由自定义的类加载器进行加载，如果不能够加载才交给父类加载器去加载。 这种情况下，就有可能有大量相同的类，被不同的自定义类加载器加载到JVM中。

ClassLoader loadloader = new ClassLoader() {  
@Override  
public Class<?> loadClass(String name) throws ClassNotFoundException {  
        try {  
            String filename = name.replace('.', '/') + ".class";   
            InputStream is = getClass().getResourceAsStream(filename); 
            if (is == null) {  
                return super.loadClass(name);  
            }  
            byte[] bt = new byte[is.available()];  
            is.read(bt);  
            return defineClass(name, bt, 0, bt.length);  
        } catch (IOException e) {  
            e.printStackTrace(); 
        }  
        return super.loadClass(name);
    }  
} 

• 重写findClass()方法
    重写findClass方法的自定义类，首先会通过父类加载器进行加载，如果所有父类加载器都无法加载，再通过用户自定义的findClass方法进行加载。如果父类加载器可以加载这个类或者当前类已经存在于某个父类的容器中了，这个类是不会再次被加载的，此时用户自定义的findClass方法就不会被执行，保证了相同全限定名的类是不会被重复加载到JVM中。

ClassLoader findloader = new ClassLoader() {  
@Override  
public Class<?> findClass(String name) throws ClassNotFoundException {  
        try {  
            String filename = name.replace('.', '/') + ".class";   
            InputStream is = getClass().getResourceAsStream(filename); 
            if (is == null) {  
                return super.findClass(name);  
            }  
            byte[] bt = new byte[is.available()];  
            is.read(bt);  
            return defineClass(name, bt, 0, bt.length);  
        } catch (IOException e) {  
            e.printStackTrace(); 
        }  
        return super.findClass(name);
    }  
}

  下图为双亲委派模型的工作示意图：

双亲委派模型

  双亲委派模型的工作过程：当一个类加载器收到类加载请求，它首先将这个请求委派给父类加载器去完成，自己不会去加载，每一个层次的类加载器都是如此。只有当父类加载器无法完成加载请求时，子类加载器才会尝试自己加载。
  使用双亲委派模型的好处在于Java类随着它的类加载器一起具备了一种带有优先级的层次关系。例如类java.lang.Object，它存在在rt.jar中，无论哪一个类加载器要加载这个类，最终都是委派给处于模型最顶端的Bootstrap ClassLoader进行加载，因此Object类在程序的各种类加载器环境中都是同一个类。相反，如果没有双亲委派模型而是由各个类加载器自行加载的话，如果用户编写了一个java.lang.Object的同名类并放在ClassPath中，那系统中将会出现多个不同的Object类。

双亲委派模型的系统实现

  在java.lang.ClassLoader的loadClass()方法中，先检查是否已经被加载过，若没有加载则调用父类加载器的loadClass()方法，若父加载器为空则默认使用启动类加载器作为父加载器。如果父加载失败，则抛出ClassNotFoundException异常后，再调用自己的findClass()方法进行加载。

protected synchronized Class<?> loadClass(String name,boolean resolve)throws ClassNotFoundException{
    // First, check if the class has already been loaded
    Class c = findLoadedClass(name);
    if(c == null){
        try{
            if(parent != null){ // use parent classloader load class
                c = parent.loadClass(name,false);
            }else{ // use bootstrap classloader load class
                c = findBootstrapClassOrNull(name);
            }
        }catch(ClassNotFoundException e){
            //if throws the exception ,the father can not complete the load
        }
        if(c == null){// If still not found, then invoke findClass in order to find the class
            c = findClass(name);
        }
    }
    if(resolve){
        resolveClass(c);
    }
    return c;
}