Tomcat源码分析之ClassLoader部分的设计详细分析

读Tomcat的源码也算是有一段时间了吧，感觉读的也是断断续续的，这次写一篇比较综合性的吧，来看看Tomcat的整体ClassLoader体系的设计。。。。

在具体的涉及到源码之前，先来一张图来整体的描述一下整体的结构吧：

这张图在以前的文章应该也出现过。。。首先整个Tomcat的classLoader分为了两条线，左边的一条线为catalinaLoader，这个是Tomcat服务器专用的，用于加载Tomcat服务器本身的class，右边的一条线则为web应用程序用的，每一个web应用程序都有自己专用的WebappClassLoader，用于加载属于自己应用程序的资源，例如/web-inf/lib下面的jar包，classes里面的class文件。。。

然后上面也体现了整体的classLoader的双亲继承关系。。。。

好啦，接下来来开始进入代码部分吧。。在整个tomcat的启动入口部分bootstrap对象的main函数中，代码如下：

Bootstrap bootstrap = new Bootstrap();  //这里创建当前Bootstarp类型的对象
      try {
        bootstrap.init();  //初始化,这里有创建classLoader，其实这里主要是创建org.apache.catalina.startup.Catalina对象并调用setParentClassLoader设置classLoader，用的是shareLoader
      } catch (Throwable t) {
        handleThrowable(t);
        t.printStackTrace();
        return;
      }
      daemon = bootstrap;   //保存当前引用到静态变量

这里主要是对bootstrap的初始化，这里面就会涉及到commonLoader，catalinaLoader与sharedLoader的创建，来看代码吧：

//初始化当前的tomcat后台，主要是创建org.apache.catalina.startup.Catalina对象，并且设置它的classLoader为catalinaLoader
  public void init() throws Exception {

    initClassLoaders();   //先初始化classLoader，包括common，catalina以及shared

    Thread.currentThread().setContextClassLoader(catalinaLoader);   //设置当前线程classLoader

    SecurityClassLoad.securityClassLoad(catalinaLoader);  //安全classLoader？

    // Load our startup class and call its process() method
    if (log.isDebugEnabled())
      log.debug("Loading startup class");
    Class<?> startupClass =
      catalinaLoader.loadClass  //这里加载catalina类型是用catalinaloader来加载的
      ("org.apache.catalina.startup.Catalina");  //获取org.apache.catalina.startup.Catalina类型
    Object startupInstance = startupClass.newInstance();  //创建org.apache.catalina.startup.Catalina对象

    // Set the shared extensions class loader
    if (log.isDebugEnabled())
      log.debug("Setting startup class properties");
    String methodName = "setParentClassLoader";
    Class<?> paramTypes[] = new Class[1];
    paramTypes[0] = Class.forName("java.lang.ClassLoader");
    Object paramValues[] = new Object[1];
    paramValues[0] = sharedLoader;  //传进这个classLoader
    Method method =
      startupInstance.getClass().getMethod(methodName, paramTypes);
    method.invoke(startupInstance, paramValues);  //调用刚刚创建的org.apache.catalina.startup.Catalina对象的setParentClassLoader设置classLoader，shareloader

    catalinaDaemon = startupInstance;  //将这个启动的实例保存起来，这里引用的是catalina的类型的对象

  }

这里有几个比较重要的部分吧，首先调用了initClassLoader方法来创建了上面提到的三个classLoader，然后这里还要注意，将当前的线程classLoader设置为了catalinaLoader，这个待会会看到具体干嘛用。。。接着就是调用创建的catalina对象的setParent方法，将sharedLoader传进去，这个也很重要。。一会就知道了。。。

这里还有一个比较重要的地方，catalina的class是用catalinaLoader加载的。。。

好了，先暂时搁置catalina部分的内容，来看看 initClassLoader方法做了啥吧：

//初始化classLoader，这里分别创建了3个classLoader，common，catalina和sharedLoader，其中common没有父亲，另外两个的父亲是common
  private void initClassLoaders() {
    try {
      commonLoader = createClassLoader("common", null);  //创建common的classloader  java.net.URLClassLoader
      if( commonLoader == null ) {
        // no config file, default to this loader - we might be in a 'single' env.
        commonLoader=this.getClass().getClassLoader();
      }
      catalinaLoader = createClassLoader("server", commonLoader);	//java.net.URLClassLoader
      sharedLoader = createClassLoader("shared", commonLoader);	//java.net.URLClassLoader
    } catch (Throwable t) {
      handleThrowable(t);
      log.error("Class loader creation threw exception", t);
      System.exit(1);
    }
  }

这里就可以看到创建了commonLoader，catalinaLoader与sharedLoader，而且可以很清楚的看到他们之间的双亲结构。。。这里我们来看看createClassLoader方法是怎么搞的吧：

//具体的创建classLoader的方法，第一个参数是当前要创建的ｌｏａｄｅｒ的名字，第二个是这个loader的双亲loader的父亲
  private ClassLoader createClassLoader(String name, ClassLoader parent)
    throws Exception {
    //首先获取要载入的资源路径
    String value = CatalinaProperties.getProperty(name + ".loader");	//"${catalina.base}/lib","${catalina.base}/lib/*.jar","${catalina.home}/lib","${catalina.home}/lib/*.jar"
    if ((value == null) || (value.equals("")))  //如果没有这个classLoader特定的资源，那么就用parent就好了
      return parent;

    value = replace(value);  //这里主要是获取当前classLoader加载资源的路径

    List<Repository> repositories = new ArrayList<>();

    String[] repositoryPaths = getPaths(value);  //将里面的路径区分开来

    for (String repository : repositoryPaths) {  //遍历所有的要载入的资源路径
      // Check for a JAR URL repository
      /*
       * G:\work eclipse workspace\tomcat8/lib
        G:\work eclipse workspace\tomcat8/lib/*.jar
        G:\work eclipse workspace\tomcat8/lib
        G:\work eclipse workspace\tomcat8/lib/*.jar
       */
      try {
        @SuppressWarnings("unused")
        URL url = new URL(repository);  // 创建路径的url引用
        repositories.add(
            new Repository(repository, RepositoryType.URL));  //将他们加入repositories
        continue;
      } catch (MalformedURLException e) {
        // Ignore
      }

      // Local repository
      if (repository.endsWith("*.jar")) {  //如果是*.jar结尾的，那么只取前面的文件夹路径就好了
        repository = repository.substring
          (0, repository.length() - "*.jar".length());
        repositories.add(
            new Repository(repository, RepositoryType.GLOB));
      } else if (repository.endsWith(".jar")) {  //如果是jar结尾的，那么表示是个jar包
        repositories.add(
            new Repository(repository, RepositoryType.JAR));
      } else {
        repositories.add(
            new Repository(repository, RepositoryType.DIR));  //其他的就是路径了
      }
    }

    return ClassLoaderFactory.createClassLoader(repositories, parent);   //创建classLoder
  }

第一个参数是要创建的classLoader的名字，第二个是该classLoader的父亲，对于commonLoader，它的父亲为null，这里首先做的是获取指定要创建的classLoader的配置信息，其实这里也就是该classLoder要载入的资源。。

这里也可以看到，如果classLoader没有自己要特定载入的资源的话，那么将不会创建，直接用parent就好了。。。

有的时候，对于sharedLoader与catalinaLoader就没有特定要创建的。。。在这种情况下就catalina，sharedLoader与commonLoader就为同一个对象。。。

当然对于最顶层的commonLoader，它是由自己要载入的资源的，路径如下：  //"${catalina.base}/lib","${catalina.base}/lib/*.jar","${catalina.home}/lib","${catalina.home}/lib/*.jar"

这也就是commonLoader要载入的主要的资源路径，因此也可以知道主要就是载入Tomcat服务器根路径下lib文件夹里面的资源。。。。最后调用ClassLoaderFactory的createClassLoader方法的时候将要载入的资源的路径引用穿件去就好了。。最终创建的classLoader其实就是类库的URLClassLoader，也就是在创建URLClassLoader对象的时候，将刚刚提到的资源的url引用传入就好了。。。。

那么到这里为止，commonLoader，catalinaLoader与sharedLoader的创建就算是比较清楚了吧。。。

接到开始的话题，在bootStrap对象的初始化方法中将当前的线程classLoader设置为了catalinaLoader，然后将创建的catalina对象的parentClassLoader设置为了sharedLoader。。。嗯。。记住。。。

好啦，接下来进入catalina对象部分，我们知道bootstrap对象的启动，实际上是调用catalina对象的start方法来具体工作的。。那么接下来进入catalina对象的start方法吧：

//创建一个tomcatServer的实例，在bootstrap对象中的启动会调用catalina的start方法来启动tomcat
  public void start() {

    if (getServer() == null) {
      load();   //加载server，这里其实主要是解析xml文件，读取里面的元素定义，用于生成server对象，并且初始化server对象
    }

    if (getServer() == null) {
      log.fatal("Cannot start server. Server instance is not configured.");
      return;
    }

    long t1 = System.nanoTime();

    // Start the new server
    try {
      getServer().start();  //调用server的start，最终启动tomcat服务器，其实server要做的是启动里面的service
    } catch (LifecycleException e) {
      log.fatal(sm.getString("catalina.serverStartFail"), e);
      try {
        getServer().destroy();
      } catch (LifecycleException e1) {
        log.debug("destroy() failed for failed Server ", e1);
      }
      return;
    }

    long t2 = System.nanoTime();
    if(log.isInfoEnabled()) {
      log.info("Server startup in " + ((t2 - t1) / 1000000) + " ms");
    }

    // Register shutdown hook
    if (useShutdownHook) {
      if (shutdownHook == null) {
        shutdownHook = new CatalinaShutdownHook();
      }
      Runtime.getRuntime().addShutdownHook(shutdownHook);

      // If JULI is being used, disable JULI's shutdown hook since
      // shutdown hooks run in parallel and log messages may be lost
      // if JULI's hook completes before the CatalinaShutdownHook()
      LogManager logManager = LogManager.getLogManager();
      if (logManager instanceof ClassLoaderLogManager) {
        ((ClassLoaderLogManager) logManager).setUseShutdownHook(
            false);
      }
    }

    if (await) {  
      await();  //阻塞当前线程
      stop();
    }
  }

这部分要做的事情，其实是创建server对象，然后启动就好了。。。然后catalina对象将会阻塞当前线程。。

那么来看看具体是怎么创建Server对象的吧：

//用于创建server对象
  public void load() {

    long t1 = System.nanoTime();

    initDirs();  //初始化一些目录参数

    // Before digester - it may be needed

    initNaming();

    // Create and execute our Digester
    Digester digester = createStartDigester();  //创建处理xml文件的对象，并会生成相应的处理规则，例如如何创建server对象，主要是处理server.xml

    InputSource inputSource = null;
    InputStream inputStream = null;
    File file = null;
    try {
      file = configFile();   //获取server.xml
      inputStream = new FileInputStream(file);   //读取server.xml
      inputSource = new InputSource(file.toURI().toURL().toString());
    } catch (Exception e) {
      if (log.isDebugEnabled()) {
        log.debug(sm.getString("catalina.configFail", file), e);
      }
    }
    if (inputStream == null) {
      try {
        inputStream = getClass().getClassLoader()
          .getResourceAsStream(getConfigFile());
        inputSource = new InputSource
          (getClass().getClassLoader()
           .getResource(getConfigFile()).toString());
      } catch (Exception e) {
        if (log.isDebugEnabled()) {
          log.debug(sm.getString("catalina.configFail",
              getConfigFile()), e);
        }
      }
    }

    // This should be included in catalina.jar
    // Alternative: don't bother with xml, just create it manually.
    if( inputStream==null ) {
      try {
        inputStream = getClass().getClassLoader()
            .getResourceAsStream("server-embed.xml");
        inputSource = new InputSource
        (getClass().getClassLoader()
            .getResource("server-embed.xml").toString());
      } catch (Exception e) {
        if (log.isDebugEnabled()) {
          log.debug(sm.getString("catalina.configFail",
              "server-embed.xml"), e);
        }
      }
    }


    if (inputStream == null || inputSource == null) {
      if  (file == null) {
        log.warn(sm.getString("catalina.configFail",
            getConfigFile() + "] or [server-embed.xml]"));
      } else {
        log.warn(sm.getString("catalina.configFail",
            file.getAbsolutePath()));
        if (file.exists() && !file.canRead()) {
          log.warn("Permissions incorrect, read permission is not allowed on the file.");
        }
      }
      return;
    }

    try {
      inputSource.setByteStream(inputStream);
      digester.push(this);   //这里先将当前对象放到Digester的栈底，但会server生成之后会调用当前对象的setServer方法来保存起来
      digester.parse(inputSource);
    } catch (SAXParseException spe) {
      log.warn("Catalina.start using " + getConfigFile() + ": " +
          spe.getMessage());
      return;
    } catch (Exception e) {
      log.warn("Catalina.start using " + getConfigFile() + ": " , e);
      return;
    } finally {
      try {
        inputStream.close();
      } catch (IOException e) {
        // Ignore
      }
    }

    getServer().setCatalina(this);  //设置sever的catalina对象
    getServer().setCatalinaHome(Bootstrap.getCatalinaHomeFile());  //设置server的目录
    getServer().setCatalinaBase(Bootstrap.getCatalinaBaseFile());

    // Stream redirection
    initStreams();

    // Start the new server
    try {
      getServer().init();   //初始化创建的server对象，其实这里主要是初始化service
    } catch (LifecycleException e) {
      if (Boolean.getBoolean("org.apache.catalina.startup.EXIT_ON_INIT_FAILURE")) {
        throw new java.lang.Error(e);
      } else {
        log.error("Catalina.start", e);
      }

    }

    long t2 = System.nanoTime();
    if(log.isInfoEnabled()) {
      log.info("Initialization processed in " + ((t2 - t1) / 1000000) + " ms");
    }

  }

这里其实主要就是创建Digester对象，然后用它来解析conf/server.xml文件，根据配置的信息来创建相应的对象，例如server对象，因此这个 Digester就算是很重要的啦。。。来看看它的创建吧：

protected Digester createStartDigester() {
  long t1=System.currentTimeMillis();
  // Initialize the digester
  Digester digester = new Digester();   //这个对象用于解析处理xml文件
  digester.setValidating(false);
  digester.setRulesValidation(true);
  HashMap<Class<?>, List<String>> fakeAttributes = new HashMap<>();
  ArrayList<String> attrs = new ArrayList<>();
  attrs.add("className");
  fakeAttributes.put(Object.class, attrs);
  digester.setFakeAttributes(fakeAttributes);
  digester.setUseContextClassLoader(true);  //将useContextClassLoader参数设置为true，那么待会将会用预先保存的线程classLoader来载入class，这里其实就是catalinaloader

  // Configure the actions we will be using
  digester.addObjectCreate("Server",
         "org.apache.catalina.core.StandardServer",
         "className");   //创建一个创建server对象的规则
  digester.addSetProperties("Server");  //创建一个设置属性的规则，那么创建完了server对象之后就会设置配置文件后面的属性
  digester.addSetNext("Server",
          "setServer",
          "org.apache.catalina.Server");   //当server元素执行完了之后，执行的操作。。。这里其实是调用前面那个对象的方法，这里其实就是调用catalina对象的setServer方法

  digester.addObjectCreate("Server/GlobalNamingResources",
         "org.apache.catalina.deploy.NamingResourcesImpl");  //创建全局名字资源
  digester.addSetProperties("Server/GlobalNamingResources");
  digester.addSetNext("Server/GlobalNamingResources",
          "setGlobalNamingResources",
          "org.apache.catalina.deploy.NamingResourcesImpl");   //其实这里实在server对象上面设置resource

  digester.addObjectCreate("Server/Listener",
         null, // MUST be specified in the element
         "className");   //根据xml文件配置来创建listener
  digester.addSetProperties("Server/Listener");  //设置listener对象配置的属性
  digester.addSetNext("Server/Listener",
          "addLifecycleListener",
          "org.apache.catalina.LifecycleListener");  //这里其实是在server对象上面添加lifecyclelistener

  digester.addObjectCreate("Server/Service",
         "org.apache.catalina.core.StandardService",
         "className");    //创建service对象
  digester.addSetProperties("Server/Service");  //设置service的属性
  digester.addSetNext("Server/Service",
          "addService",  //在server对象上面调用addService方法
          "org.apache.catalina.Service");   //在server上面添加调用addService方法

  //为service创建listener，不一定有
  digester.addObjectCreate("Server/Service/Listener",
         null, // MUST be specified in the element
         "className");    //根据配置文件参数来创建service的listener
  digester.addSetProperties("Server/Service/Listener");
  digester.addSetNext("Server/Service/Listener",
          "addLifecycleListener",
          "org.apache.catalina.LifecycleListener");

  //Executor
  //创建service的executor，这个不一定有
  digester.addObjectCreate("Server/Service/Executor",
       "org.apache.catalina.core.StandardThreadExecutor",
       "className");
  digester.addSetProperties("Server/Service/Executor");

  digester.addSetNext("Server/Service/Executor",
          "addExecutor",
          "org.apache.catalina.Executor");

  //为servie添加connector规则
  digester.addRule("Server/Service/Connector",
       new ConnectorCreateRule());    //这个规则会创建connector，而且如果有属性执行executor的话，还会设置connector的executor
  digester.addRule("Server/Service/Connector",  //<Connector port="8080" protocol="HTTP/1.1" connectionTimeout="20000" redirectPort="8443"/>
       new SetAllPropertiesRule(new String[]{"executor"}));   //这里会将所有的属性都设置，除了executor
  digester.addSetNext("Server/Service/Connector",
          "addConnector",
          "org.apache.catalina.connector.Connector");  //在service上面添加这个connector


  //这里是设置connector的listener
  digester.addObjectCreate("Server/Service/Connector/Listener",
         null, // MUST be specified in the element
         "className");
  digester.addSetProperties("Server/Service/Connector/Listener");
  digester.addSetNext("Server/Service/Connector/Listener",
          "addLifecycleListener",
          "org.apache.catalina.LifecycleListener");

  // Add RuleSets for nested elements
  digester.addRuleSet(new NamingRuleSet("Server/GlobalNamingResources/"));
  digester.addRuleSet(new EngineRuleSet("Server/Service/"));   //engine元素的定义的处理，这里主要是创建eingie
  digester.addRuleSet(new HostRuleSet("Server/Service/Engine/"));  //engine里面host的定义
  digester.addRuleSet(new ContextRuleSet("Server/Service/Engine/Host/"));  //一些context的配置处理
  addClusterRuleSet(digester, "Server/Service/Engine/Host/Cluster/");
  digester.addRuleSet(new NamingRuleSet("Server/Service/Engine/Host/Context/"));

  // When the 'engine' is found, set the parentClassLoader.
  digester.addRule("Server/Service/Engine",
       new SetParentClassLoaderRule(parentClassLoader));  //如果有发现engine，那么设置container(Engine对象)的parentClassloader，shareloader
  addClusterRuleSet(digester, "Server/Service/Engine/Cluster/");

  long t2=System.currentTimeMillis();
  if (log.isDebugEnabled()) {
      log.debug("Digester for server.xml created " + ( t2-t1 ));
  }	
  return (digester);

    }

这里可以其实主要就是对于server.xml文件的处理规则，有几点需要搞清楚：

（1） digester.setUseContextClassLoader(true);这句代码，将会对Digester进行设置，待会创建对象的时候加载class的时候将会用到当前线程的classLoader，这个在前面已经强调，当前线程classLoader被设置为了catalinaLoader

（2）来看看是如何创建对象的吧，这里对于对象的创建将会创建一个ObjectCreateRule规则，这里来看看这个规则是怎么处理的吧：

//当遇到需要创建元素的element的时候要做的事情
    @Override
    public void begin(String namespace, String name, Attributes attributes)
      throws Exception {

  // Identify the name of the class to instantiate
  String realClassName = className;
  if (attributeName != null) {
      String value = attributes.getValue(attributeName);    //看是否有指定的属性
      if (value != null) {
    realClassName = value;
      }
  }
  if (digester.log.isDebugEnabled()) {
      digester.log.debug("[ObjectCreateRule]{" + digester.match +
        "}New " + realClassName);
  }

  if (realClassName == null) {
      throw new NullPointerException("No class name specified for " +
        namespace + " " + name);
  }

  // Instantiate the new object and push it on the context stack
  Class<?> clazz = digester.getClassLoader().loadClass(realClassName);  //用classloader来载入class
  Object instance = clazz.newInstance();  //创建这个对象
  digester.push(instance);  //放入digester
    }

这里其实主要就是调用classLoader的loadClass方法来加载class，然后创建对象。。。那么这里用的是什么classLoader呢。。？来看看：

public ClassLoader getClassLoader() {

    if (this.classLoader != null) {
      return (this.classLoader);
    }
    if (this.useContextClassLoader) {  //这里一般都是用这里，线程classLoader，在bootstarp里面设置为catalinaLoader
      ClassLoader classLoader =
          Thread.currentThread().getContextClassLoader();
      if (classLoader != null) {
        return (classLoader);
      }
    }
    return (this.getClass().getClassLoader());

  }

到这里就很清楚了吧，前面已经提到了，这里将会采用当前线程classLoader，也就是catalinaLoader，这里也就可以知道，对于Server对象所有东西的创建，其class的都是用的catalinaLoader。。

嗯。。。这也就是为啥说catalinaLoader是Tomcat服务器专用的了，整个Tomcat服务器的重要对象创建用到的loader都是它。。。

（3）注意一句代码： digester.addRule("Server/Service/Engine", 
                         new SetParentClassLoaderRule(parentClassLoader));  //如果有发现engine，那么设置container(Engine对象)的parentClassloader，shareloader

它创建的规则将会将创建的engine对象的parentClassLoader设置为当前catalina对象的parentClassLoader，前面就已经说过了，当前catalina对象的parentClassLoader被设置为了sharedLoader，那么表示engine对象的parentClassLoader也会是sharedLoader。。。

（4）我们来看看创建host对象的用到的规则：

//创建host对象
        digester.addObjectCreate(prefix + "Host",
          "org.apache.catalina.core.StandardHost",  //创建host对象的配置
          "className");
        digester.addSetProperties(prefix + "Host");
        digester.addRule(prefix + "Host",
  new CopyParentClassLoaderRule());  //会将host的parentClassloader设置为engine的，engine被设置为sharedloader

这里可以看到在host的创建中加了一个CopyParentClassLoaderRule规则，它的作用是将当前对象的parentClassLoader设置为上一层对象的parentClassLoader，host外面就是engine，那么可以知道将会将host的parentClassLoader也设置为sharedLoader。。。 

好了，到这里catalina部分对classLoader的处理就差不多了。。。

到现在位置,我们知道在tomcat的启动的时候,载入tomcat系统相关的额class都是采用的catalinaLoader

然后还有在catalina对象中将parentClassLoader设置为了sharedLoader，然后engine的parentClassLoader也被设置为了sharedLoader，然后host对象的parentClassLoader也被设置为了sharedLoader，嗯，这个为以后context部分的内容埋下了伏笔。。。

好了，接下来就开始进入Context部分吧，我们知道一个Context基本上就代表了web应用程序，前面提到，每一个web应用程序都有自己专有的classLoader，那么接下来就来看看这个是如何创建的吧。。。在StandardContext的startInternal方法中，我们可以看到如下的代码：

//loader部分
        if (getLoader() == null) { //这一步用于创建loader对象
            WebappLoader webappLoader = new WebappLoader(getParentClassLoader());    //这里用于创建当前context用的classLoader，这里会将parent设置为sharedclassLoader
            webappLoader.setDelegate(getDelegate());  
            setLoader(webappLoader);  //保存创建的loader
        }

这里是创建了WebappLoader对象，然后注意看这里传入了当前context对象的parentClassLoader，那么我们来看看这个方法：

public ClassLoader getParentClassLoader() {
    if (parentClassLoader != null) {
      return (parentClassLoader);
    } if (getPrivileged()) {
      return this.getClass().getClassLoader();
    } else if (parent != null) {  //一般都是使用parent的parentClassLoader，也就是host的，host将会设置为与engine一样，也就是sharedLoader
      return (parent.getParentClassLoader());
    }
    return (ClassLoader.getSystemClassLoader());
  }

由于在创建context对象的时候并没有指定parentClassLoader，所以这里返回的将是context对象的parent的parentClassLoader，。我们知道context的parent是host对象，而host对象的parentclassLoader已经被设置为了sharedLoader，所以在这里创建webapploader的时候穿进去的构造参数其实也就是sharedLoader。。。

来看看WebappLoader的构造函数吧：

public WebappLoader(ClassLoader parent) {
        super();
        this.parentClassLoader = parent;  //parentClassLoader，一般都是sharedLoader
    }

嗯，这里好像也就是主要将传进来的sharedLoader保存起来。。那么在来看看Webapploader对象是如何启动的吧：

//启动webapploader
  protected void startInternal() throws LifecycleException {

    if (log.isDebugEnabled())
      log.debug(sm.getString("webappLoader.starting"));

    if (context.getResources() == null) {
      log.info("No resources for " + context);
      setState(LifecycleState.STARTING);
      return;
    }

    // Construct a class loader based on our current repositories list
    try {

      classLoader = createClassLoader();  //创建classLoader  org.apache.catalina.loader.WebappClassLoader
      classLoader.setResources(context.getResources());  //设置资源目录
      classLoader.setDelegate(this.delegate);

      // Configure our repositories
      setClassPath();  //设置classPath

      setPermissions();

      ((Lifecycle) classLoader).start();  //启动classLoader，里面主要是加载classes以及lib下的代码

      String contextName = context.getName();  //获取当前context的名字
      if (!contextName.startsWith("/")) {
        contextName = "/" + contextName;
      }
      ObjectName cloname = new ObjectName(context.getDomain() +
          ":type=WebappClassLoader,host=" + context.getParent().getName() +
          ",context=" + contextName);
      Registry.getRegistry(null, null)
        .registerComponent(classLoader, cloname, null);   //在jmx上面注册

    } catch (Throwable t) {
      t = ExceptionUtils.unwrapInvocationTargetException(t);
      ExceptionUtils.handleThrowable(t);
      log.error( "LifecycleException ", t );
      throw new LifecycleException("start: ", t);
    }

    setState(LifecycleState.STARTING);
  }

这里可以知道WebappLoader有一个classLoader的属性，将会在启动的时候创建，创建完了之后还会涉及到为这个classLoader设置资源，然后启动这个classLoader。。。

好啦，那就先来看看是如何创建的吧：

//创建webappclassLoader，这里会将sharedLoader设置为parent
  private WebappClassLoader createClassLoader()
    throws Exception {

    Class<?> clazz = Class.forName(loaderClass);  //获取要创建的classLoader的class引用  org.apache.catalina.loader.WebappClassLoader
    WebappClassLoader classLoader = null;

    if (parentClassLoader == null) {
      parentClassLoader = context.getParentClassLoader();	//获取context的parentClassLoader，这里是sharedLoader
    }
    Class<?>[] argTypes = { ClassLoader.class };
    Object[] args = { parentClassLoader };
    Constructor<?> constr = clazz.getConstructor(argTypes);  //获取构造函数，这里需要传递一个parentClassLoader，其实这里的双亲loader就是sharedLoader
    classLoader = (WebappClassLoader) constr.newInstance(args);

    return classLoader;
  }

这里就很明白了，创建了一个WebappClassLoader对象，并且将其的双亲loader设置为了sharedLoader。。。。

其实到这里整个tomcat的整体的classLoader就算了解的差不多了。。

最后再来看看WebappClassLoader是怎么启动的吧：

//其实主要是加载classes与lib下的代码，jar啥的
  public void start() throws LifecycleException {

    WebResource classes = resources.getResource("/WEB-INF/classes");  //获取/WEB-INF/classes目录的资源引用
    if (classes.isDirectory() && classes.canRead()) {
      addURL(classes.getURL());   //将该资源添加到当前classLoader的资源库
    }
    WebResource[] jars = resources.listResources("/WEB-INF/lib");  //这里是获取lib文件夹
    for (WebResource jar : jars) {  //遍历所有的资源 
      if (jar.getName().endsWith(".jar") && jar.isFile() && jar.canRead()) {
        addURL(jar.getURL());  // 将资源加入到classLoader的资源库
        jarModificationTimes.put(
            jar.getName(), Long.valueOf(jar.getLastModified()));
      }
    }

    started = true;
    String encoding = null;
    try {
      encoding = System.getProperty("file.encoding");
    } catch (SecurityException e) {
      return;
    }
    if (encoding.indexOf("EBCDIC")!=-1) {
      needConvert = true;
    }

  }

这个代码看起来应该就很熟悉吧，加载/WEB-INF/classes以及/WEB-INF/lib下面的资源。。。

好啦。。classLoader部分就算完事了。。。可以看出tomcat8中对classLoader的处理比jetty6中还是要细致一些的。。。