深入解析Java中的Classloader的运行机制

java有两种类型的classload,一种是user-defined的，一种是jvm内置的bootstrap class loader，所有user-defined的class loader都是java.lang.classloader的子类.

而jvm内置的class loader有3种，分别是 bootstrap classloader， extension classloader（即extclassloader），system classloader(即appclassloader).

而jvm加载时的双亲委派 就不说了，javaeye上有很多文章都有介绍..
可以分别看一下他们的构造器，其中bootstrap classloader是用c写的.
java.lang.classloader

  protected classloader(classloader parent) {
 securitymanager security = system.getsecuritymanager();
 if (security != null) {
   security.checkcreateclassloader();
 }
//给父loader赋值.
 this.parent = parent;
 initialized = true;
  }
  protected classloader() {
 securitymanager security = system.getsecuritymanager();
 if (security != null) {
   security.checkcreateclassloader();
 }
//这边将会把appclassloader付给父loader
 this.parent = getsystemclassloader();
 initialized = true;
  }

这个构造器有带参数的，和不带构造器的2个。带参数的构造器传入的是这个 class loader的父loader,而不带参数的构造器则会把getsystemclassloader()所返回的class loader当作他自己的父装载器.下面我们来看getsystemclassloader()的代码

public static classloader getsystemclassloader() {
//所返回的class loader在这个方法里面被赋值
 initsystemclassloader();
 if (scl == null) {
   return null;
 }
 securitymanager sm = system.getsecuritymanager();
 if (sm != null) {
   classloader ccl = getcallerclassloader();
   if (ccl != null && ccl != scl && !scl.isancestor(ccl)) {
 sm.checkpermission(securityconstants.get_classloader_permission);
   }
 }
 return scl;
  }

  private static synchronized void initsystemclassloader() {
 if (!sclset) {
   if (scl != null)
 throw new illegalstateexception("recursive invocation");
      sun.misc.launcher l = sun.misc.launcher.getlauncher();
   if (l != null) {
 throwable oops = null;
//在这边被赋值
 scl = l.getclassloader();
     ...................................
.......................................
 }
   }
   sclset = true;
 }
  }

这边的父class loader就是scl，也就是l.getclassloader()所得到的,getclassloader(),接下来看launcher的源码：
private static launcher launcher = new launcher();

  public static launcher getlauncher() {
 return launcher;
  }

  private classloader loader;

  public launcher() {
 // create the extension class loader
 classloader extcl;
 try {
//这里传入构造器的parent为空
   extcl = extclassloader.getextclassloader();
 } catch (ioexception e) {
   throw new internalerror(
 "could not create extension class loader");
 }

 // now create the class loader to use to launch the application
 try {
//这边可以看到默认的loader就是appclassloader,也就是说getsystemclassloader返回的就是appclassloader
   loader = appclassloader.getappclassloader(extcl);
 } catch (ioexception e) {
   throw new internalerror(
 "could not create application class loader");
 }
//每一个当前线程一个classload,以防止多线程中的classload引起的混乱(这个是我自己理解的，呵呵)
 // also set the context class loader for the primordial thread.
 thread.currentthread().setcontextclassloader(loader);

 ...................................
................................................
  }

  /*
   * returns the class loader used to launch the main application.
   */
  public classloader getclassloader() {
 return loader;
  }

从中我们看到appclassloader的父loader是extclassloader,而extclassloader的父loader是什么呢？我们在来看extclassloader的构造器:

public extclassloader(file[] dirs) throws ioexception {
   super(getexturls(dirs), null, factory);
   this.dirs = dirs;
 }

他的父loader为空，而他的*父类是java.lang.classloader而当传入的parent为null时，我们使用 extclassloader load一个类时，系统会调用bootstrap classloader.

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) {
//先调用父loader来load.
   c = parent.loadclass(name, false);
 } else {
//调用bootstrap classloader来load
   c = findbootstrapclass0(name);
 }
   } catch (classnotfoundexception e) {
     // if still not found, then invoke findclass in order
     // to find the class.
     c = findclass(name);
   }
 }
 if (resolve) {
   resolveclass(c);
 }
 return c;
  }

而这里findbootstrapclass0也就是调用bootstrap classloader这个最核心的class loader来load class.

最终我们可以看到getsystemclassloader() 返回的class loader就是appclassloader.

java classloader机制解析

jdk默认classloader
jdk 默认提供了如下几种classloader

bootstrp loader
bootstrp加载器是用c++语言写的，它是在java虚拟机启动后初始化的，它主要负责加载%java_home%/jre/lib,-xbootclasspath参数指定的路径以及%java_home%/jre/classes中的类。

extclassloader 
bootstrp loader加载extclassloader,并且将extclassloader的父加载器设置为bootstrp loader.extclassloader是用java写的，具体来说就是 sun.misc.launcher$extclassloader，extclassloader主要加载%java_home%/jre/lib/ext，此路径下的所有classes目录以及java.ext.dirs系统变量指定的路径中类库。

appclassloader
bootstrp loader加载完extclassloader后，就会加载appclassloader,并且将appclassloader的父加载器指定为 extclassloader。appclassloader也是用java写成的，它的实现类是 sun.misc.launcher$appclassloader，另外我们知道classloader中有个getsystemclassloader方法,此方法返回的正是appclassloader.appclassloader主要负责加载classpath所指定的位置的类或者是jar文档，它也是java程序默认的类加载器。

综上所述，它们之间的关系可以通过下图形象的描述：

双亲委托模型
java中classloader的加载采用了双亲委托机制，采用双亲委托机制加载类的时候采用如下的几个步骤：

当前classloader首先从自己已经加载的类中查询是否此类已经加载，如果已经加载则直接返回原来已经加载的类。

每个类加载器都有自己的加载缓存，当一个类被加载了以后就会放入缓存，等下次加载的时候就可以直接返回了。

当前classloader的缓存中没有找到被加载的类的时候，委托父类加载器去加载，父类加载器采用同样的策略，首先查看自己的缓存，然后委托父类的父类去加载，一直到bootstrp classloader.

当所有的父类加载器都没有加载的时候，再由当前的类加载器加载，并将其放入它自己的缓存中，以便下次有加载请求的时候直接返回。

说到这里大家可能会想，java为什么要采用这样的委托机制？理解这个问题，我们引入另外一个关于classloader的概念“命名空间”， 它是指要确定某一个类，需要类的全限定名以及加载此类的classloader来共同确定。也就是说即使两个类的全限定名是相同的，但是因为不同的 classloader加载了此类，那么在jvm中它是不同的类。明白了命名空间以后，我们再来看看委托模型。采用了委托模型以后加大了不同的 classloader的交互能力，比如上面说的，我们jdk本生提供的类库，比如hashmap,linkedlist等等，这些类由bootstrp 类加载器加载了以后，无论你程序中有多少个类加载器，那么这些类其实都是可以共享的，这样就避免了不同的类加载器加载了同样名字的不同类以后造成混乱。

如何自定义classloader
java除了上面所说的默认提供的classloader以外，它还容许应用程序可以自定义classloader，那么要想自定义classloader我们需要通过继承java.lang.classloader来实现,接下来我们就来看看再自定义classloader的时候，我们需要注意的几个重要的方法：

1.loadclass 方法

loadclass method declare

public class<?> loadclass(string name) throws classnotfoundexception

上面是loadclass方法的原型声明，上面所说的双亲委托机制的实现其实就实在此方法中实现的。下面我们就来看看此方法的代码来看看它到底如何实现双亲委托的。

loadclass method implement

public class<?> loadclass(string name) throws classnotfoundexception
 { 
return loadclass(name, false);
}

从上面可以看出loadclass方法调用了loadcclass(name,false)方法，那么接下来我们再来看看另外一个loadclass方法的实现。

class loadclass(string name, boolean resolve)

protected synchronized class<?> loadclass(string name, boolean resolve) throws classnotfoundexception  
 { // first, check if the class has already been loaded class c = findloadedclass(name);
//检查class是否已经被加载过了 if (c == null)
 {   
 try {   
if (parent != null) {     
 c = parent.loadclass(name, false); //如果没有被加载，且指定了父类加载器，则委托父加载器加载。  
 } else {    
 c = findbootstrapclass0(name);//如果没有父类加载器，则委托bootstrap加载器加载   } 
   } catch (classnotfoundexception e) {     
 // if still not found, then invoke findclass in order     
// to find the class.     
 c = findclass(name);//如果父类加载没有加载到，则通过自己的findclass来加载。   } 
 } 
 if (resolve) 
{   
 resolveclass(c); 
 } 
return c;
}

上面的代码，我加了注释通过注释可以清晰看出loadclass的双亲委托机制是如何工作的。 这里我们需要注意一点就是public class<?> loadclass(string name) throws classnotfoundexception没有被标记为final，也就意味着我们是可以override这个方法的，也就是说双亲委托机制是可以打破的。另外上面注意到有个findclass方法，接下来我们就来说说这个方法到底是搞末子的。

2.findclass

我们查看java.lang.classloader的源代码，我们发现findclass的实现如下：

protected class<?> findclass(string name) throws classnotfoundexception
 { 
throw new classnotfoundexception(name);
}

我们可以看出此方法默认的实现是直接抛出异常，其实这个方法就是留给我们应用程序来override的。那么具体的实现就看你的实现逻辑了，你可以从磁盘读取，也可以从网络上获取class文件的字节流，获取class二进制了以后就可以交给defineclass来实现进一步的加载。defineclass我们再下面再来描述。 ok，通过上面的分析，我们可以得出如下结论：

我们在写自己的classloader的时候，如果想遵循双亲委托机制，则只需要override findclass.

3.defineclass

我们首先还是来看看defineclass的源码：

defineclass

protected final class<?> defineclass(string name, byte[] b, int off, int len) 
throws classformaterror
{   
 return defineclass(name, b, off, len, null);
}

从上面的代码我们看出此方法被定义为了final，这也就意味着此方法不能被override，其实这也是jvm留给我们的唯一的入口，通过这个唯 一的入口，jvm保证了类文件必须符合java虚拟机规范规定的类的定义。此方法最后会调用native的方法来实现真正的类的加载工作。

ok,通过上面的描述，我们来思考下面一个问题：
假如我们自己写了一个java.lang.string的类，我们是否可以替换调jdk本身的类？

答案是否定的。我们不能实现。为什么呢？我看很多网上解释是说双亲委托机制解决这个问题，其实不是非常的准确。因为双亲委托机制是可以打破的，你完全可以自己写一个classloader来加载自己写的java.lang.string类，但是你会发现也不会加载成功，具体就是因为针对java.*开头的类，jvm的实现中已经保证了必须由bootstrp来加载。

不遵循“双亲委托机制”的场景
上面说了双亲委托机制主要是为了实现不同的classloader之间加载的类的交互问题，被大家公用的类就交由父加载器去加载，但是java中确实也存在父类加载器加载的类需要用到子加载器加载的类的情况。下面我们就来说说这种情况的发生。

java中有一个spi(service provider interface)标准,使用了spi的库，比如jdbc，jndi等，我们都知道jdbc需要第三方提供的驱动才可以，而驱动的jar包是放在我们应 用程序本身的classpath的，而jdbc 本身的api是jdk提供的一部分，它已经被bootstrp加载了，那第三方厂商提供的实现类怎么加载呢？这里面java引入了线程上下文类加载的概 念，线程类加载器默认会从父线程继承，如果没有指定的话，默认就是系统类加载器（appclassloader）,这样的话当加载第三方驱动的时候，就可 以通过线程的上下文类加载器来加载。
另外为了实现更灵活的类加载器osgi以及一些java app server也打破了双亲委托机制。