【Tomcat】二.Tomcat启动初始化Boostrap

发表于 更新于 分类于 ， ， 本文字数： 3.4k 阅读时长 ≈ 12 分钟

零.Bootstrap初始化

Bootstrap 可以看成是一个 TomcatServer 运行时需要的环境的准备，这里通过加载配置文件，设置全局数据以便让后面的 组件 初始化的时候可以使用到。

一.获取Tomcat运行的配置目录

那么首先是在 static代码块 中获取到运行环境的目录基础：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
public final class Bootstrap {
  private static final Log log = LogFactory.getLog(Bootstrap.class);

    /**
     * Daemon object used by main.
     */
    private static final Object daemonLock = new Object();
    // 声明一个Bootstrap静默线程的对象引用，main方法将会用到
    private static volatile Bootstrap daemon = null;
    private static final File catalinaBaseFile;
    private static final File catalinaHomeFile;
    private static final Pattern PATH_PATTERN = Pattern.compile("(\".*?\")(([^,])*)");

    static {
        // 获取当前运行的绝对路径
        String userDir = System.getProperty("user.dir");
        // 获取catalina.home的值
        String home = System.getProperty(Globals.CATALINA_HOME_PROP);
        File homeFile = null;
        if (home != null) {
            File f = new File(home);
            try {
                homeFile = f.getCanonicalFile();
            } catch (IOException ioe) {
                homeFile = f.getAbsoluteFile();
            }
        }
        // 两次尝试获取homeFile的值，不过刚开始我们就配置了，所以这两个判断直接跳过
        if (homeFile == null) {
            File bootstrapJar = new File(userDir, "bootstrap.jar");
            if (bootstrapJar.exists()) {
                File f = new File(userDir, "..");
                try {
                    homeFile = f.getCanonicalFile();
                } catch (IOException ioe) {
                    homeFile = f.getAbsoluteFile();
                }
            }
        }
        if (homeFile == null) {
            // Second fall-back. Use current directory
            File f = new File(userDir);
            try {
                homeFile = f.getCanonicalFile();
            } catch (IOException ioe) {
                homeFile = f.getAbsoluteFile();
            }
        }

        // 存储到Boostrap的静态变量中.
        catalinaHomeFile = homeFile;
        System.setProperty(
                Globals.CATALINA_HOME_PROP, catalinaHomeFile.getPath());

        // 然后获取catalina.base的值，也同样存储到System属性中
        String base = System.getProperty(Globals.CATALINA_BASE_PROP);
        if (base == null) {
            catalinaBaseFile = catalinaHomeFile;
        } else {
            File baseFile = new File(base);
            try {
                baseFile = baseFile.getCanonicalFile();
            } catch (IOException ioe) {
                baseFile = baseFile.getAbsoluteFile();
            }
            catalinaBaseFile = baseFile;
        }
        System.setProperty(
                Globals.CATALINA_BASE_PROP, catalinaBaseFile.getPath());
    }
  // .......省略其他代码
}

二.读取运行参数

既然第一步已经初始化好了运行时所需要使用的 文件路径，那么接下来肯定就是读取配置并且根据配置来初始化项目了。这一步就直接在 main 方法中进行调用：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
public final class Bootstrap {
      public static void main(String args[]) {
        // 加锁初始化 Boostrap 的静默引用
        synchronized (daemonLock) {
            if (daemon == null) {
                // Don't set daemon until init() has completed
                Bootstrap bootstrap = new Bootstrap();
                try {
                    bootstrap.init();
                } catch (Throwable t) {
                    handleThrowable(t);
                    t.printStackTrace();
                    return;
                }
                // 持有引用
                daemon = bootstrap;
            } else {
                Thread.currentThread().setContextClassLoader(daemon.catalinaLoader);
            }
        }

        // 根据运行的命令做相对应的操作
        try {
            String command = "start";
            if (args.length > 0) {
                command = args[args.length - 1];
            }

            if (command.equals("startd")) {
                args[args.length - 1] = "start";
                daemon.load(args);
                daemon.start();
            } else if (command.equals("stopd")) {
                args[args.length - 1] = "stop";
                daemon.stop();
            } else if (command.equals("start")) {
                // init初始化以后就需要进入到这里来启动Tomcat服务
                daemon.setAwait(true);
                daemon.load(args);
                daemon.start();
                if (null == daemon.getServer()) {
                    System.exit(1);
                }
            } else if (command.equals("stop")) {
                daemon.stopServer(args);
            } else if (command.equals("configtest")) {
                daemon.load(args);
                if (null == daemon.getServer()) {
                    System.exit(1);
                }
                System.exit(0);
            } else {
                log.warn("Bootstrap: command \"" + command + "\" does not exist.");
            }
        } catch (Throwable t) {
            // Unwrap the Exception for clearer error reporting
            if (t instanceof InvocationTargetException &&
                    t.getCause() != null) {
                t = t.getCause();
            }
            handleThrowable(t);
            t.printStackTrace();
            System.exit(1);
        }
    }
}

2.1 Bootstrap初始化

包括初始化自定义的 ClassLoader 以及 Catalina 的准备工作。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
public void init() throws Exception {
  // 初始化三个ClassLoader
  initClassLoaders();
  // 将当前线程的ClassLoader设置成Catalina的Loader
  Thread.currentThread().setContextClassLoader(catalinaLoader);

  SecurityClassLoad.securityClassLoad(catalinaLoader);

  // 通过反射，做 Catalina 的准备工作
  if (log.isDebugEnabled())
    log.debug("Loading startup class");
  Class<?> startupClass = catalinaLoader.loadClass("org.apache.catalina.startup.Catalina");
  Object startupInstance = startupClass.getConstructor().newInstance();

  // 将 sharedLoader 设置成 Catalina 的父级 ClassLoader
  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;
  Method method =
    startupInstance.getClass().getMethod(methodName, paramTypes);
  method.invoke(startupInstance, paramValues);

  catalinaDaemon = startupInstance;
}

首先需要初始化三个 ClassLoader（但其实到最后三个都指向 commonLoader）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
private void initClassLoaders() {
  try {
    commonLoader = createClassLoader("common", null);
    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);
    sharedLoader = createClassLoader("shared", commonLoader);
  } catch (Throwable t) {
    handleThrowable(t);
    log.error("Class loader creation threw exception", t);
    System.exit(1);
  }
}

那么我们现在就有这些 ClassLoader：

每一层加载 Class 的时候， Loader 就都会说：你去找你爷去，找到最后没有找到，才退下来一层，如果找到了就返回，到最后都没有找到就会抛出 ClassNotFoundException。 所以这种方式可以很好的防止我们使用一个同样的类，对 Tomcat 造成破坏。 根据 catalina-home/conf/catalina.properties 的配置创建初始化 ClassLoader。我们使用的是默认配置：

1
2
3
common.loader="${catalina.base}/lib","${catalina.base}/lib/*.jar","${catalina.home}/lib","${catalina.home}/lib/*.jar"
server.loader=
shared.loader=

由于只有 common.loader 配置了规则，所以下面两个在创建的时候由于没有配置，直接将 commonClassLoader 返回了。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
private ClassLoader createClassLoader(String name, ClassLoader parent)
  throws Exception {
  // 通过读取 catalina-home/conf/catalina.properties 的配置，
  // 如果没有配置，则返回直接返回父级的ClassLoader
  String value = CatalinaProperties.getProperty(name + ".loader");
  // 默认情况下，shared和Catalina的ClassLoader都没有配置，直接返回了CommonLoader实例
  if ((value == null)  (value.equals("")))
    return parent;

  value = replace(value);

  // 在加载CommonLoader的时候加载了 lib 文件夹下的所有jar包.
  List<Repository> repositories = new ArrayList<>();
  String[] repositoryPaths = getPaths(value);
  // 循环 catalina-home/catalina.properties 配置的规则的路径，
  // 使用 URL 加载 jar 包
  for (String repository : repositoryPaths) {
    // Check for a JAR URL repository
    try {
      @SuppressWarnings("unused")
      URL url = new URL(repository);
      repositories.add(new Repository(repository, RepositoryType.URL));
      continue;
    } catch (MalformedURLException e) {
      // Ignore
    }

    // Local repository
    if (repository.endsWith("*.jar")) {
      repository = repository.substring
        (0, repository.length() - "*.jar".length());
      repositories.add(new Repository(repository, RepositoryType.GLOB));
    } else if (repository.endsWith(".jar")) {
      repositories.add(new Repository(repository, RepositoryType.JAR));
    } else {
      repositories.add(new Repository(repository, RepositoryType.DIR));
    }
  }

  return ClassLoaderFactory.createClassLoader(repositories, parent);
}

更进一步的就不打算走下去了，只要知道目前 commonClassLoader 加载了 lib 下的所有包就可以了。

2.2 Bootstrap启动

加载完 jar 包目录，接下来就是启动了，在 main 方法里面我们可以直接看这几句话：

1
2
3
4
5
6
7
8
9
else if (command.equals("start")) {
  // init初始化以后就需要进入到这里来启动Tomcat服务
  daemon.setAwait(true);
  daemon.load(args);
  daemon.start();
  if (null == daemon.getServer()) {
    System.exit(1);
  }
}

首先，设置 Catalina 进行等候：

1
2
3
4
5
6
7
8
9
10
11
public void setAwait(boolean await)
        throws Exception {

  Class<?> paramTypes[] = new Class[1];
  paramTypes[0] = Boolean.TYPE;
  Object paramValues[] = new Object[1];
  paramValues[0] = Boolean.valueOf(await);
  Method method =
    catalinaDaemon.getClass().getMethod("setAwait", paramTypes);
  method.invoke(catalinaDaemon, paramValues);
}

我们可以看到 Bootstrap 设置 Catalina 的时候，一直都是通过反射的形式调用，这是因为 Boostrap 要保证 Catalina 类和 XML读取的相关工具 在不同的 ClassLoader 中，从而可以保证 Catalina 加载的我们 war 项目不可以访问到 Tomcat的关键类。

Catalina：蛮好听的名字，查了一下百度资料，Catalina 是美国西海岸靠近洛杉矶22英里的一个小岛，因为其风景秀丽而著名。 Servlet 运行模块的最早开发者 Craig McClanahan 因为喜欢 Catalina岛 故以 Catalina 命名他所开这个模块，尽管他从来也没有去过那里。 另外在开发的早期阶段，Tomcat是被搭建在一个叫 Avalon 的服务器框架上，而 Avalon 则是 Catalina 岛上的一个小镇的名字，于是想一个与小镇名字相关联的单词也是自然而然。还有一个原因来自于 Craig McClanahan 养的猫，他养的猫在他写程序的时候喜欢在电脑周围闲逛。

那就想象成 Bootstrap 把这个岛建立起来了！。 那第二句 daemon.load(args); 也是通过反射调用，代码就不贴了，直接进入 Catalina.class#load()。

三.Catalina加载配置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
public class Catalina {

  public void load() {
    // 装配 server.xml 的配置
    if (loaded) {
      return;
    }
    loaded = true;
    long t1 = System.nanoTime();
    initDirs();
    initNaming();
    Digester digester = createStartDigester();
    InputSource inputSource = null;
    InputStream inputStream = null;
    File file = null;
    try {
      try {
        file = configFile();
        inputStream = new FileInputStream(file);
        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.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 {
      if (inputStream != null) {
        try {
          inputStream.close();
        } catch (IOException e) {
          // Ignore
        }
      }
    }
    // 保存Server的一些信息：
    getServer().setCatalina(this);
    getServer().setCatalinaHome(Bootstrap.getCatalinaHomeFile());
    getServer().setCatalinaBase(Bootstrap.getCatalinaBaseFile());

    // 将日志输出流从默认的 System.out 替换成 Tomcat 自己的实现.
    initStreams();

    // 开始初始化 Server，也就是最大的一层。
    try {
      getServer().init();
    } 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");
    }
  }

}

看人家配置解析，Emm还是蛮无聊的，直接跳过去了。只要知道是根据 server.xml 解析创建对象就可以了，在这个过程中，实例化了 server 对象。 那么接下来就需要初始化里面的内容了，我们大概还记得这个图：


getServer().init(); 相当于初始化 TomcatServer。 我们知道一个 Service 包含了 Connector 和 Engine，所以初始化肯定涉及这两个鬼：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
public class StandardService extends LifecycleMBeanBase implements Service {

  @Override
  protected void initInternal() throws LifecycleException {

    super.initInternal();

    // 初始化Engine
    if (engine != null) {
      engine.init();
    }

    // 默认是空的执行器
    for (Executor executor : findExecutors()) {
      if (executor instanceof JmxEnabled) {
        ((JmxEnabled) executor).setDomain(getDomain());
      }
      executor.init();
    }

    // 初始化监听器
    mapperListener.init();

    // 初始化Connector
    synchronized (connectorsLock) {
      for (Connector connector : connectors) {
        try {
          connector.init();
        } catch (Exception e) {
          String message = sm.getString(
            "standardService.connector.initFailed", connector);
          log.error(message, e);

          if (Boolean.getBoolean("org.apache.catalina.startup.EXIT_ON_INIT_FAILURE"))
            throw new LifecycleException(message);
        }
      }
    }
  }

}

四.StandardServer初始化

4.1 lifecycle生命周期转换

StandardServer 就需要先看看 Lifecycle 接口了：

这个接口规范了在 Tomcat 运行期间的 生命周期函数。只要跟 Tomcat 一起运行的，就会有这些 生命周期。 与此同时还有个 LifecycleBase 实现了基本的生命周期转换：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public abstract class LifecycleBase implements Lifecycle {

  @Override
  public final synchronized void init() throws LifecycleException {
    if (!state.equals(LifecycleState.NEW)) {
      invalidTransition(Lifecycle.BEFORE_INIT_EVENT);
    }

    try {
      setStateInternal(LifecycleState.INITIALIZING, null, false);
      initInternal();
      setStateInternal(LifecycleState.INITIALIZED, null, false);
    } catch (Throwable t) {
      handleSubClassException(t, "lifecycleBase.initFail", toString());
    }
  }

  // 子类实现这个即可实现转换
  protected abstract void initInternal() throws LifecycleException;

}

4.2 StandardServer初始化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
public final class StandardServer extends LifecycleMBeanBase implements Server {


  @Override
  protected void initInternal() throws LifecycleException {

    super.initInternal();

    // String注册
    onameStringCache = register(new StringCache(), "type=StringCache");

    // 注册MBeanFactory，用来创建
    MBeanFactory factory = new MBeanFactory();
    factory.setContainer(this);
    onameMBeanFactory = register(factory, "type=MBeanFactory");

    // 初始化全局组件名字的组件
    globalNamingResources.init();

    if (getCatalina() != null) {
      ClassLoader cl = getCatalina().getParentClassLoader();
      // 加载 shared 和 common ClassLoader 的Jar包，一直到 SystemClassLoader
      while (cl != null && cl != ClassLoader.getSystemClassLoader()) {
        if (cl instanceof URLClassLoader) {
          URL[] urls = ((URLClassLoader) cl).getURLs();
          for (URL url : urls) {
            if (url.getProtocol().equals("file")) {
              try {
                File f = new File (url.toURI());
                if (f.isFile() &&
                    f.getName().endsWith(".jar")) {
                  ExtensionValidator.addSystemResource(f);
                }
              } catch (URISyntaxException e) {
                // Ignore
              } catch (IOException e) {
                // Ignore
              }
            }
          }
        }
        cl = cl.getParent();
      }
    }
    // 初始化Service
    for (int i = 0; i < services.length; i++) {
      services[i].init();
    }
  }

}

加载了一些 Jar 包，然后就初始化我们最熟悉的 Service。

五.StandardService初始化

同样的实现了 Lifecycle 接口，所以我们只需要关注 initInternal 即可。那我们知道 Service 是包含一个 Engine 和 接收数据的 Connector 的。所以他的初始化主要是关注这两者：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
public class StandardService extends LifecycleMBeanBase implements Service {
  @Override
  protected void initInternal() throws LifecycleException {

    super.initInternal();

    // 初始化Engine
    if (engine != null) {
      engine.init();
    }

    // 默认是空的执行器
    for (Executor executor : findExecutors()) {
      if (executor instanceof JmxEnabled) {
        ((JmxEnabled) executor).setDomain(getDomain());
      }
      executor.init();
    }

    // 初始化监听器
    mapperListener.init();

    // 初始化Connector
    synchronized (connectorsLock) {
      for (Connector connector : connectors) {
        try {
          connector.init();
        } catch (Exception e) {
          String message = sm.getString(
            "standardService.connector.initFailed", connector);
          log.error(message, e);

          if (Boolean.getBoolean("org.apache.catalina.startup.EXIT_ON_INIT_FAILURE"))
            throw new LifecycleException(message);
        }
      }
    }
  }
}

六.Engine初始化

Engine 默认实现是 StandardEngine ：

1
2
3
4
5
6
7
8
9
10
public class StandardEngine extends ContainerBase implements Engine {

  @Override
  protected void initInternal() throws LifecycleException {
    // Realm，一个认证的东西，这里保证加载成功
    getRealm();
    super.initInternal();
  }

}

来瞄一下配置文件：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
<Server>  
  <!-- 省略 -->
    <Service name="Catalina">
    <Connector port="8080" protocol="HTTP/1.1"
               connectionTimeout="20000"
               redirectPort="8443" />
    <Connector port="8009" protocol="AJP/1.3" redirectPort="8443" secretRequired=""/>
    <Engine name="Catalina" defaultHost="localhost">
        <!-- 这是一个混合的Realm认证，可以包含其他的 Realm -->
      <Realm className="org.apache.catalina.realm.LockOutRealm">
        <Realm className="org.apache.catalina.realm.UserDatabaseRealm"
               resourceName="UserDatabase"/>
      </Realm>
      <Host name="localhost"  appBase="webapps"
            unpackWARs="true" autoDeploy="true">
        <Valve className="org.apache.catalina.valves.AccessLogValve" directory="logs"
               prefix="localhost_access_log" suffix=".txt"
               pattern="%h %l %u %t "%r" %s %b" />
      </Host>
    </Engine>
  </Service>
</Server>

LockOutRealm 是一个可以组合子 Realm 的类，规定了在一定时间内 用户鉴权出错次数，超出次数则会返回错误。不过项目中一般不用这个。 接下来 super.initInternal() ，父类不是 LifecycleBase 了，而是另外一个类：ContainerBase

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public abstract class ContainerBase extends LifecycleMBeanBase
        implements Container {
  @Override
  protected void initInternal() throws LifecycleException {
    BlockingQueue<Runnable> startStopQueue = new LinkedBlockingQueue<>();
    startStopExecutor = new ThreadPoolExecutor(
      getStartStopThreadsInternal(),
      getStartStopThreadsInternal(), 10, TimeUnit.SECONDS,
      startStopQueue,
      new StartStopThreadFactory(getName() + "-startStop-"));
    startStopExecutor.allowCoreThreadTimeOut(true);
    super.initInternal();
  }
}

这就是初始化线程池实例以便后续可以让项目可以并行执行部署。

七.MapperListener初始化

这个容器主要处理 HOST 以及 URI 映射的 Servlet。初始化没做什么事情，只是注册了个名字，先跳过不看。

八.Connector初始化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
public class Connector extends LifecycleMBeanBase  { 
  @Override
  protected void initInternal() throws LifecycleException {

    super.initInternal();

    // Initialize adapter
    adapter = new CoyoteAdapter(this);
    protocolHandler.setAdapter(adapter);

    // Make sure parseBodyMethodsSet has a default
    if (null == parseBodyMethodsSet) {
      // 设置需要解析消息体的HTTPMethod
      setParseBodyMethods(getParseBodyMethods());
    }

    if (protocolHandler.isAprRequired() && !AprLifecycleListener.isInstanceCreated()) {
      throw new LifecycleException(sm.getString("coyoteConnector.protocolHandlerNoAprListener",
                                                getProtocolHandlerClassName()));
    }
    if (protocolHandler.isAprRequired() && !AprLifecycleListener.isAprAvailable()) {
      throw new LifecycleException(sm.getString("coyoteConnector.protocolHandlerNoAprLibrary",
                                                getProtocolHandlerClassName()));
    }
    if (AprLifecycleListener.isAprAvailable() && AprLifecycleListener.getUseOpenSSL() &&
        protocolHandler instanceof AbstractHttp11JsseProtocol) {
      AbstractHttp11JsseProtocol<?> jsseProtocolHandler =
        (AbstractHttp11JsseProtocol<?>) protocolHandler;
      if (jsseProtocolHandler.isSSLEnabled() &&
          jsseProtocolHandler.getSslImplementationName() == null) {
        // OpenSSL is compatible with the JSSE configuration, so use it if APR is available
        jsseProtocolHandler.setSslImplementationName(OpenSSLImplementation.class.getName());
      }
    }

    try {
      // 初始化协议处理器：Http11NIOProtocol
      protocolHandler.init();
    } catch (Exception e) {
      throw new LifecycleException(
        sm.getString("coyoteConnector.protocolHandlerInitializationFailed"), e);
    }
  }

  public void setParseBodyMethods(String methods) {

    HashSet<String> methodSet = new HashSet<>();

    if (null != methods) {
      methodSet.addAll(Arrays.asList(methods.split("\\s*,\\s*")));
    }

    if (methodSet.contains("TRACE")) {
      throw new IllegalArgumentException(sm.getString("coyoteConnector.parseBodyMethodNoTrace"));
    }

    this.parseBodyMethods = methods;
    this.parseBodyMethodsSet = methodSet;
    setProperty("parseBodyMethods", methods);
  }
}

九.Http11NIOProtocol初始化

Http11NIOProtocol 是一个 HTTP 1.1 的解析器，所以他需要负责 Request 和 Response 的解析，所以，这里又通过一个 Endpoint 组件来做，所以需要初始化 Endpont

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
public abstract class AbstractProtocol<S> implements ProtocolHandler, MBeanRegistration {
  @Override
  public void init() throws Exception {
    if (getLog().isInfoEnabled()) {
      getLog().info(sm.getString("abstractProtocolHandler.init", getName()));
    }

    if (oname == null) {
      oname = createObjectName();
      if (oname != null) {
        Registry.getRegistry(null, null).registerComponent(this, oname, null);
      }
    }

    if (this.domain != null) {
      // 与域名绑定解析器
      rgOname = new ObjectName(domain + ":type=GlobalRequestProcessor,name=" + getName());
      Registry.getRegistry(null, null).registerComponent(
        getHandler().getGlobal(), rgOname, null);
    }

    // 获取接口名字并初始化，接口在这里的意思是管理Socket数据进出的意思
    String endpointName = getName();
    // Endpoint在解析server.xml被初始化，现在是设置一些数据
    endpoint.setName(endpointName.substring(1, endpointName.length()-1));
    endpoint.setDomain(domain);

    endpoint.init();
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public abstract class AbstractJsseEndpoint<S> extends AbstractEndpoint<S> {

  @Override
  public void init() throws Exception {
    testServerCipherSuitesOrderSupport();
    super.init();
  }

  private void testServerCipherSuitesOrderSupport() {
    // JDK8下不支持使用SSLImplementation实现类，估计是修复Bug时需要hhh
    if(!JreCompat.isJre8Available() &&
       !OpenSSLImplementation.class.getName().equals(getSslImplementationName())) {
      for (SSLHostConfig sslHostConfig : sslHostConfigs.values()) {
        if (sslHostConfig.getHonorCipherOrder() != null) {
          throw new UnsupportedOperationException(
            sm.getString("endpoint.jsse.cannotHonorServerCipherOrder"));
        }
      }
    }
  }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
public abstract class AbstractEndpoint<S> {


  public void init() throws Exception {
    if (bindOnInit) {
      bind();
      bindState = BindState.BOUND_ON_INIT;
    }
    if (this.domain != null) {
      // Register endpoint (as ThreadPool - historical name)
      oname = new ObjectName(domain + ":type=ThreadPool,name=\"" + getName() + "\"");
      Registry.getRegistry(null, null).registerComponent(this, oname, null);

      ObjectName socketPropertiesOname = new ObjectName(domain +
                                                        ":type=ThreadPool,name=\"" + getName() + "\",subType=SocketProperties");
      socketProperties.setObjectName(socketPropertiesOname);
      Registry.getRegistry(null, null).registerComponent(socketProperties, socketPropertiesOname, null);

      for (SSLHostConfig sslHostConfig : findSslHostConfigs()) {
        registerJmx(sslHostConfig);
      }
    }
  }


}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
public class NioEndpoint extends AbstractJsseEndpoint<NioChannel> {

  /**
    * Initialize the endpoint.
    */
  @Override
  public void bind() throws Exception {

    // 使用NIO的类库打开绑定端口
    if (!getUseInheritedChannel()) {
      serverSock = ServerSocketChannel.open();
      socketProperties.setProperties(serverSock.socket());
      InetSocketAddress addr = (getAddress()!=null?new InetSocketAddress(getAddress(),getPort()):new InetSocketAddress(getPort()));
      serverSock.socket().bind(addr,getAcceptCount());
    } else {
      // ...
    }
    serverSock.configureBlocking(true); //mimic APR behavior

    // Initialize thread count defaults for acceptor, poller
    if (acceptorThreadCount == 0) {
      // FIXME: Doesn't seem to work that well with multiple accept threads
      acceptorThreadCount = 1;
    }
    if (pollerThreadCount <= 0) {
      //minimum one poller thread
      pollerThreadCount = 1;
    }
    setStopLatch(new CountDownLatch(pollerThreadCount));

    // Initialize SSL if needed
    initialiseSsl();

    selectorPool.open();
  }
}

关于 NIO内核 后面再详细了解了。 一路跳出来，Catalina 的 load() 方法就走完了，至于 start() 丢下一篇。