devbox
天景科技苑
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

tomcat-整启动流程-源码解析

作者：天景科技苑 | 2024-06-21 02:12:56

赞

踩

tomcat启动流程源码

tomcat-目录&总体架构

Tomcat整体启动流程

    上文了解了大致tomat的相关架构，那么本文是针对tomcat的启动流程进行了解，。tomcat是通过Bootstrap的main方法进行启动，然后通过catalina对象中创建server.xml的解析器，一步到位创建出大部分组件，通过责任链模式进行层层管理。细节可以跟着调试代码关注如下。

源码位置：https://gitee.com/hong99/source-code-learning.git

tomcat整体架构

b53709e58c03ab06d9bc708baa165973.png

tomcat的核心启动入口（所有的启动入口）

6efce38f946bc8ec05e86e6e46ef0e2b.png

代码位置

注意：bootstrap调用顺序main->init->load

org.apache.catalina.startup.Bootstrap#main

  1. /**
  2.  * Main method and entry point when starting Tomcat via the provided
  3.  * scripts.
  4.  *
  5.  * @param args Command line arguments to be processed
  6.  * tomcat 核心启动类 主线程类
  7.  */
  8. public static void main(String args[]) {
  9.     //线程同步方式启动
  10.     synchronized (daemonLock) {
  11.         if (daemon == null) {
  12.             //创建 自身
  13.             Bootstrap bootstrap = new Bootstrap();
  14.             try {
  15.                 //创建 tomcat自身的初始化
  16.                 bootstrap.init();
  17.             } catch (Throwable t) {
  18.                 handleThrowable(t);
  19.                 t.printStackTrace();
  20.                 return;
  21.             }
  22.             daemon = bootstrap;
  23.         } else {
  24.             // When running as a service the call to stop will be on a new
  25.             // thread so make sure the correct class loader is used to
  26.             // prevent a range of class not found exceptions.
  27.             Thread.currentThread().setContextClassLoader(daemon.catalinaLoader);
  28.         }
  29.     }
  30.  
  31.     try {
  32.         //默认为启动 标识
  33.         String command = "start";
  34.         //如果args长度大于0
  35.         if (args.length > 0) {
  36.             //重新赋值
  37.             command = args[args.length - 1];
  38.         }
  39.  
  40.         if (command.equals("startd")) {
  41.             args[args.length - 1] = "start";
  42.             daemon.load(args);
  43.             daemon.start();
  44.         } else if (command.equals("stopd")) {
  45.             args[args.length - 1] = "stop";
  46.             daemon.stop();
  47.         } else if (command.equals("start")) {
  48.             //线程等待，否则tomcat直接就关闭了;就类似于守护线程
  49.             daemon.setAwait(true);
  50.             //加载
  51.             daemon.load(args);
  52.             daemon.start();
  53.             if (null == daemon.getServer()) {
  54.                 System.exit(1);
  55.             }
  56.         } else if (command.equals("stop")) {
  57.             daemon.stopServer(args);
  58.         } else if (command.equals("configtest")) {
  59.             daemon.load(args);
  60.             if (null == daemon.getServer()) {
  61.                 System.exit(1);
  62.             }
  63.             System.exit(0);
  64.         } else {
  65.             log.warn("Bootstrap: command \"" + command + "\" does not exist.");
  66.         }
  67.     } catch (Throwable t) {
  68.         // Unwrap the Exception for clearer error reporting
  69.         if (t instanceof InvocationTargetException &&
  70.                 t.getCause() != null) {
  71.             t = t.getCause();
  72.         }
  73.         handleThrowable(t);
  74.         t.printStackTrace();
  75.         System.exit(1);
  76.     }
  77. }

main执行中，第一步初始化就是init，通过这个init进行初始化所有下级;

org.apache.catalina.startup.Bootstrap#init()

  1. /**
  2.  * bootstartp 初始化方法
  3.  * Initialize daemon.
  4.  * @throws Exception Fatal initialization error
  5.  */
  6. public void init() throws Exception {
  7.     //初始化类加载器 其中包含 catalinaLoader和sharedLoader
  8.     initClassLoaders();
  9.     //将catalinaLoader 放到当前线上下文中
  10.     Thread.currentThread().setContextClassLoader(catalinaLoader);
  11.     //将catalinaLoader 加载到权限管理中
  12.     SecurityClassLoad.securityClassLoad(catalinaLoader);
  13.  
  14.     // 是否打印日志开关
  15.     if (log.isDebugEnabled()) {
  16.         log.debug("Loading startup class");
  17.     }
  18.     //通过反射方式调用 catalina方法
  19.     Class<?> startupClass = catalinaLoader.loadClass("org.apache.catalina.startup.Catalina");
  20.     Object startupInstance = startupClass.getConstructor().newInstance();
  21.  
  22.     // Set the shared extensions class loader
  23.     if (log.isDebugEnabled()) {
  24.         log.debug("Setting startup class properties");
  25.     }
  26.     //方法名称为：setParentClassLoader
  27.     String methodName = "setParentClassLoader";
  28.     Class<?> paramTypes[] = new Class[1];
  29.     paramTypes[0] = Class.forName("java.lang.ClassLoader");
  30.     Object paramValues[] = new Object[1];
  31.     //类加载器
  32.     paramValues[0] = sharedLoader;
  33.     Method method =
  34.         startupInstance.getClass().getMethod(methodName, paramTypes);
  35.     //通过反射方式调用
  36.     method.invoke(startupInstance, paramValues);
  37.     //将这个对象赋值到 catalinaDaemon
  38.     catalinaDaemon = startupInstance;
  39. }

org.apache.catalina.startup.Bootstrap#load

  1. private void load(String[] arguments) throws Exception {
  2.  
  3.     // Call the load() method 加载的方法名称为load
  4.     String methodName = "load";
  5.     Object param[];
  6.     Class<?> paramTypes[];
  7.     //当arguments为空或长度为0时将paramTypes和param 赋为空。
  8.     if (arguments==null || arguments.length==0) {
  9.         paramTypes = null;
  10.         param = null;
  11.     } else {
  12.         paramTypes = new Class[1];
  13.         paramTypes[0] = arguments.getClass();
  14.         param = new Object[1];
  15.         param[0] = arguments;
  16.     }
  17.     //通过 server.xml获取org.apache.catalina.startup.Catalina里面的方法为load
  18.     Method method =
  19.         catalinaDaemon.getClass().getMethod(methodName, paramTypes);
  20.     if (log.isDebugEnabled()) {
  21.         log.debug("Calling startup class " + method);
  22.     }
  23.     //通过反射调用 catalina里面的load无参方法
  24.     method.invoke(catalinaDaemon, param);
  25. }

到这里就跳出去调catalina的无参load方法。

那么Catalina的调用顺序是：load()->createStartDigester()->getServer().init()

主要的目的是加载sever.xml然后去初始化server，这里注意所有的加载都是通过责任链进行管理，所以getServer都是通过org.apache.catalina.util.LifecycleBase#init进行加载;

org.apache.catalina.startup.Catalina#load()

  1. public void load() {
  2.     //如果为false则直接返回
  3.     if (loaded) {
  4.         return;
  5.     }
  6.     loaded = true;
  7.  
  8.     long t1 = System.nanoTime();
  9.     //空方法 该方式不做其他操作
  10.     initDirs();
  11.  
  12.     // Before digester - it may be needed
  13.     initNaming();
  14.  
  15.     // Create and execute our Digester
  16.     Digester digester = createStartDigester();
  17.  
  18.     InputSource inputSource = null;
  19.     InputStream inputStream = null;
  20.     File file = null;
  21.     //以下是通过流的方式进行加载，然后解析
  22.     try {
  23.         try {
  24.             file = configFile();
  25.             inputStream = new FileInputStream(file);
  26.             inputSource = new InputSource(file.toURI().toURL().toString());
  27.         } catch (Exception e) {
  28.             if (log.isDebugEnabled()) {
  29.                 log.debug(sm.getString("catalina.configFail", file), e);
  30.             }
  31.         }
  32.         if (inputStream == null) {
  33.             try {
  34.                 inputStream = getClass().getClassLoader()
  35.                     .getResourceAsStream(getConfigFile());
  36.                 inputSource = new InputSource
  37.                     (getClass().getClassLoader()
  38.                      .getResource(getConfigFile()).toString());
  39.             } catch (Exception e) {
  40.                 if (log.isDebugEnabled()) {
  41.                     log.debug(sm.getString("catalina.configFail",
  42.                             getConfigFile()), e);
  43.                 }
  44.             }
  45.         }
  46.  
  47.         // This should be included in catalina.jar
  48.         // Alternative: don't bother with xml, just create it manually.
  49.         if (inputStream == null) {
  50.             try {
  51.                 inputStream = getClass().getClassLoader()
  52.                         .getResourceAsStream("server-embed.xml");
  53.                 inputSource = new InputSource
  54.                 (getClass().getClassLoader()
  55.                         .getResource("server-embed.xml").toString());
  56.             } catch (Exception e) {
  57.                 if (log.isDebugEnabled()) {
  58.                     log.debug(sm.getString("catalina.configFail",
  59.                             "server-embed.xml"), e);
  60.                 }
  61.             }
  62.         }
  63.  
  64.  
  65.         if (inputStream == null || inputSource == null) {
  66.             if  (file == null) {
  67.                 log.warn(sm.getString("catalina.configFail",
  68.                         getConfigFile() + "] or [server-embed.xml]"));
  69.             } else {
  70.                 log.warn(sm.getString("catalina.configFail",
  71.                         file.getAbsolutePath()));
  72.                 if (file.exists() && !file.canRead()) {
  73.                     log.warn("Permissions incorrect, read permission is not allowed on the file.");
  74.                 }
  75.             }
  76.             return;
  77.         }
  78.  
  79.         try {
  80.             inputSource.setByteStream(inputStream);
  81.             digester.push(this);
  82.             //最终在这里进行解析;
  83.             digester.parse(inputSource);
  84.         } catch (SAXParseException spe) {
  85.             log.warn("Catalina.start using " + getConfigFile() + ": " +
  86.                     spe.getMessage());
  87.             return;
  88.         } catch (Exception e) {
  89.             log.warn("Catalina.start using " + getConfigFile() + ": " , e);
  90.             return;
  91.         }
  92.     } finally {
  93.         if (inputStream != null) {
  94.             try {
  95.                 //关闭流
  96.                 inputStream.close();
  97.             } catch (IOException e) {
  98.                 // Ignore
  99.             }
  100.         }
  101.     }
  102.     //进行双向绑定 绑定到server中，而catalina也可以获取到server。
  103.     getServer().setCatalina(this);
  104.     getServer().setCatalinaHome(Bootstrap.getCatalinaHomeFile());
  105.     getServer().setCatalinaBase(Bootstrap.getCatalinaBaseFile());
  106.  
  107.     // Stream redirection
  108.     initStreams();
  109.  
  110.     // Start the new server
  111.     try {
  112.         //启动服务 这些是通过责任链进行管理 进行初始化操作
  113.         getServer().init();
  114.     } catch (LifecycleException e) {
  115.         if (Boolean.getBoolean("org.apache.catalina.startup.EXIT_ON_INIT_FAILURE")) {
  116.             throw new java.lang.Error(e);
  117.         } else {
  118.             log.error("Catalina.start", e);
  119.         }
  120.     }
  121.  
  122.     long t2 = System.nanoTime();
  123.     if(log.isInfoEnabled()) {
  124.         log.info("Initialization processed in " + ((t2 - t1) / 1000000) + " ms");
  125.     }
  126. }

org.apache.catalina.startup.Catalina#createStartDigester

  1. protected Digester createStartDigester() {
  2.     long t1=System.currentTimeMillis();
  3.     // Initialize the digester 初始化解析器
  4.     Digester digester = new Digester();
  5.     //解析器标志为false
  6.     digester.setValidating(false);
  7.     //执行标记为成
  8.     digester.setRulesValidation(true);
  9.     //用于存放对象信息 其中包含 类名 来源 端口编移配置
  10.     Map<Class<?>, List<String>> fakeAttributes = new HashMap<>();
  11.     // Ignore className on all elements
  12.     List<String> objectAttrs = new ArrayList<>();
  13.     objectAttrs.add("className");
  14.     fakeAttributes.put(Object.class, objectAttrs);
  15.     // Ignore attribute added by Eclipse for its internal tracking
  16.     List<String> contextAttrs = new ArrayList<>();
  17.     contextAttrs.add("source");
  18.     fakeAttributes.put(StandardContext.class, contextAttrs);
  19.     // Ignore Connector attribute used internally but set on Server
  20.     List<String> connectorAttrs = new ArrayList<>();
  21.     connectorAttrs.add("portOffset");
  22.     fakeAttributes.put(Connector.class, connectorAttrs);
  23.     digester.setFakeAttributes(fakeAttributes);
  24.     digester.setUseContextClassLoader(true);
  25.  
  26.     // Configure the actions we will be using
  27.     //以下这些都是在xml的类型
  28.     digester.addObjectCreate("Server",
  29.                              "org.apache.catalina.core.StandardServer",
  30.                              "className");
  31.     digester.addSetProperties("Server");
  32.     digester.addSetNext("Server",
  33.                         "setServer",
  34.                         "org.apache.catalina.Server");
  35.  
  36.     digester.addObjectCreate("Server/GlobalNamingResources",
  37.                              "org.apache.catalina.deploy.NamingResourcesImpl");
  38.     digester.addSetProperties("Server/GlobalNamingResources");
  39.     digester.addSetNext("Server/GlobalNamingResources",
  40.                         "setGlobalNamingResources",
  41.                         "org.apache.catalina.deploy.NamingResourcesImpl");
  42.  
  43.     digester.addObjectCreate("Server/Listener",
  44.                              null, // MUST be specified in the element
  45.                              "className");
  46.     digester.addSetProperties("Server/Listener");
  47.     digester.addSetNext("Server/Listener",
  48.                         "addLifecycleListener",
  49.                         "org.apache.catalina.LifecycleListener");
  50.  
  51.     digester.addObjectCreate("Server/Service",
  52.                              "org.apache.catalina.core.StandardService",
  53.                              "className");
  54.     digester.addSetProperties("Server/Service");
  55.     digester.addSetNext("Server/Service",
  56.                         "addService",
  57.                         "org.apache.catalina.Service");
  58.  
  59.     digester.addObjectCreate("Server/Service/Listener",
  60.                              null, // MUST be specified in the element
  61.                              "className");
  62.     digester.addSetProperties("Server/Service/Listener");
  63.     digester.addSetNext("Server/Service/Listener",
  64.                         "addLifecycleListener",
  65.                         "org.apache.catalina.LifecycleListener");
  66.  
  67.     //Executor 该线程池在最新版本中被屏蔽了 可查看server.xml <Connector executor="tomcatThreadPool"
  68.     digester.addObjectCreate("Server/Service/Executor",
  69.                      "org.apache.catalina.core.StandardThreadExecutor",
  70.                      "className");
  71.     digester.addSetProperties("Server/Service/Executor");
  72.  
  73.     digester.addSetNext("Server/Service/Executor",
  74.                         "addExecutor",
  75.                         "org.apache.catalina.Executor");
  76.  
  77.     digester.addRule("Server/Service/Connector",
  78.                      new ConnectorCreateRule());
  79.     digester.addRule("Server/Service/Connector",
  80.                      new SetAllPropertiesRule(new String[]{"executor", "sslImplementationName"}));
  81.     digester.addSetNext("Server/Service/Connector",
  82.                         "addConnector",
  83.                         "org.apache.catalina.connector.Connector");
  84.  
  85.     digester.addRule("Server/Service/Connector", new AddPortOffsetRule());
  86.  
  87.     digester.addObjectCreate("Server/Service/Connector/SSLHostConfig",
  88.                              "org.apache.tomcat.util.net.SSLHostConfig");
  89.     digester.addSetProperties("Server/Service/Connector/SSLHostConfig");
  90.     digester.addSetNext("Server/Service/Connector/SSLHostConfig",
  91.             "addSslHostConfig",
  92.             "org.apache.tomcat.util.net.SSLHostConfig");
  93.  
  94.     digester.addRule("Server/Service/Connector/SSLHostConfig/Certificate",
  95.                      new CertificateCreateRule());
  96.     digester.addRule("Server/Service/Connector/SSLHostConfig/Certificate",
  97.                      new SetAllPropertiesRule(new String[]{"type"}));
  98.     digester.addSetNext("Server/Service/Connector/SSLHostConfig/Certificate",
  99.                         "addCertificate",
  100.                         "org.apache.tomcat.util.net.SSLHostConfigCertificate");
  101.  
  102.     digester.addObjectCreate("Server/Service/Connector/SSLHostConfig/OpenSSLConf",
  103.                              "org.apache.tomcat.util.net.openssl.OpenSSLConf");
  104.     digester.addSetProperties("Server/Service/Connector/SSLHostConfig/OpenSSLConf");
  105.     digester.addSetNext("Server/Service/Connector/SSLHostConfig/OpenSSLConf",
  106.                         "setOpenSslConf",
  107.                         "org.apache.tomcat.util.net.openssl.OpenSSLConf");
  108.  
  109.     digester.addObjectCreate("Server/Service/Connector/SSLHostConfig/OpenSSLConf/OpenSSLConfCmd",
  110.                              "org.apache.tomcat.util.net.openssl.OpenSSLConfCmd");
  111.     digester.addSetProperties("Server/Service/Connector/SSLHostConfig/OpenSSLConf/OpenSSLConfCmd");
  112.     digester.addSetNext("Server/Service/Connector/SSLHostConfig/OpenSSLConf/OpenSSLConfCmd",
  113.                         "addCmd",
  114.                         "org.apache.tomcat.util.net.openssl.OpenSSLConfCmd");
  115.  
  116.     digester.addObjectCreate("Server/Service/Connector/Listener",
  117.                              null, // MUST be specified in the element
  118.                              "className");
  119.     digester.addSetProperties("Server/Service/Connector/Listener");
  120.     digester.addSetNext("Server/Service/Connector/Listener",
  121.                         "addLifecycleListener",
  122.                         "org.apache.catalina.LifecycleListener");
  123.  
  124.     digester.addObjectCreate("Server/Service/Connector/UpgradeProtocol",
  125.                               null, // MUST be specified in the element
  126.                               "className");
  127.     digester.addSetProperties("Server/Service/Connector/UpgradeProtocol");
  128.     digester.addSetNext("Server/Service/Connector/UpgradeProtocol",
  129.                         "addUpgradeProtocol",
  130.                         "org.apache.coyote.UpgradeProtocol");
  131.  
  132.     // Add RuleSets for nested elements
  133.     digester.addRuleSet(new NamingRuleSet("Server/GlobalNamingResources/"));
  134.     digester.addRuleSet(new EngineRuleSet("Server/Service/"));
  135.     digester.addRuleSet(new HostRuleSet("Server/Service/Engine/"));
  136.     digester.addRuleSet(new ContextRuleSet("Server/Service/Engine/Host/"));
  137.     addClusterRuleSet(digester, "Server/Service/Engine/Host/Cluster/");
  138.     digester.addRuleSet(new NamingRuleSet("Server/Service/Engine/Host/Context/"));
  139.  
  140.     // When the 'engine' is found, set the parentClassLoader.
  141.     digester.addRule("Server/Service/Engine",
  142.                      new SetParentClassLoaderRule(parentClassLoader));
  143.     addClusterRuleSet(digester, "Server/Service/Engine/Cluster/");
  144.  
  145.     long t2=System.currentTimeMillis();
  146.     if (log.isDebugEnabled()) {
  147.         log.debug("Digester for server.xml created " + ( t2-t1 ));
  148.     }
  149.     return digester;
  150.  
  151. }

org.apache.catalina.util.LifecycleBase#init

通过责任链管理生命周期;

  1. @Override
  2. public final synchronized void init() throws LifecycleException {
  3.     if (!state.equals(LifecycleState.NEW)) {
  4.         invalidTransition(Lifecycle.BEFORE_INIT_EVENT);
  5.     }
  6.  
  7.     try {
  8.         //设置生命周期状态
  9.         setStateInternal(LifecycleState.INITIALIZING, null, false);
  10.         initInternal();
  11.         setStateInternal(LifecycleState.INITIALIZED, null, false);
  12.     } catch (Throwable t) {
  13.         handleSubClassException(t, "lifecycleBase.initFail", toString());
  14.     }
  15. }

通过以上的initInternal()进入StandardServer#initInternal方法;

这里注意：StandardServer的执行顺序是：initInterna->NamingResourcesImpl#initInternal->service.init();

通过initInterna 为初始化server容器然后通过初始化NamingResourcesImpl#initInternal是JNIDI的数据连接服务，然后再初始多个service

org.apache.catalina.core.StandardServer#initInternal

  1. @Override
  2. protected void initInternal() throws LifecycleException {
  3.  
  4.     super.initInternal();
  5.  
  6.     // Register global String cache
  7.     // Note although the cache is global, if there are multiple Servers
  8.     // present in the JVM (may happen when embedding) then the same cache
  9.     // will be registered under multiple names
  10.     onameStringCache = register(new StringCache(), "type=StringCache");
  11.  
  12.     // Register the MBeanFactory
  13.     MBeanFactory factory = new MBeanFactory();
  14.     factory.setContainer(this);
  15.     onameMBeanFactory = register(factory, "type=MBeanFactory");
  16.  
  17.     // Register the naming resources
  18.     globalNamingResources.init();
  19.  
  20.     // Populate the extension validator with JARs from common and shared
  21.     // class loaders
  22.     if (getCatalina() != null) {
  23.         ClassLoader cl = getCatalina().getParentClassLoader();
  24.         // Walk the class loader hierarchy. Stop at the system class loader.
  25.         // This will add the shared (if present) and common class loaders
  26.         while (cl != null && cl != ClassLoader.getSystemClassLoader()) {
  27.             if (cl instanceof URLClassLoader) {
  28.                 URL[] urls = ((URLClassLoader) cl).getURLs();
  29.                 for (URL url : urls) {
  30.                     if (url.getProtocol().equals("file")) {
  31.                         try {
  32.                             File f = new File (url.toURI());
  33.                             if (f.isFile() &&
  34.                                     f.getName().endsWith(".jar")) {
  35.                                 ExtensionValidator.addSystemResource(f);
  36.                             }
  37.                         } catch (URISyntaxException | IOException e) {
  38.                             // Ignore
  39.                         }
  40.                     }
  41.                 }
  42.             }
  43.             cl = cl.getParent();
  44.         }
  45.     }
  46.     // Initialize our defined Services 初始化service
  47.     for (Service service : services) {
  48.         service.init();
  49.     }
  50. }

org.apache.catalina.deploy.NamingResourcesImpl#initInternal

  1. //加载 web.xml 中<resource-ref> 的资源配置
  2. @Override
  3. protected void initInternal() throws LifecycleException {
  4.     super.initInternal();
  5.  
  6.     // Set this before we register currently known naming resources to avoid
  7.     // timing issues. Duplication registration is not an issue.
  8.     resourceRequireExplicitRegistration = true;
  9.     //循环创建
  10.     for (ContextResource cr : resources.values()) {
  11.         try {
  12.             MBeanUtils.createMBean(cr);
  13.         } catch (Exception e) {
  14.             log.warn(sm.getString(
  15.                     "namingResources.mbeanCreateFail", cr.getName()), e);
  16.         }
  17.     }
  18.     //循环创建多个
  19.     for (ContextEnvironment ce : envs.values()) {
  20.         try {
  21.             MBeanUtils.createMBean(ce);
  22.         } catch (Exception e) {
  23.             log.warn(sm.getString(
  24.                     "namingResources.mbeanCreateFail", ce.getName()), e);
  25.         }
  26.     }
  27.  
  28.     for (ContextResourceLink crl : resourceLinks.values()) {
  29.         try {
  30.             MBeanUtils.createMBean(crl);
  31.         } catch (Exception e) {
  32.             log.warn(sm.getString(
  33.                     "namingResources.mbeanCreateFail", crl.getName()), e);
  34.         }
  35.     }
  36. }

org.apache.catalina.core.StandardService#initInternal

执行顺序：initInternal->org.apache.catalina.core.StandardEngine#initInternal->connector.init();

  1. @Override
  2. protected void initInternal() throws LifecycleException {
  3.  
  4.     super.initInternal();
  5.  
  6.     if (engine != null) {
  7.         //初始化engine的角色信息
  8.         engine.init();
  9.     }
  10.  
  11.     // Initialize any Executors 在tomcat8后以后在web.xml中被屏蔽了
  12.     for (Executor executor : findExecutors()) {
  13.         if (executor instanceof JmxEnabled) {
  14.             ((JmxEnabled) executor).setDomain(getDomain());
  15.         }
  16.         executor.init();
  17.     }
  18.  
  19.     // Initialize mapper listener 初始化生命周期bean中
  20.     mapperListener.init();
  21.  
  22.     // Initialize our defined Connectors 同步对象锁
  23.     synchronized (connectorsLock) {
  24.         //初始化多个connector
  25.         for (Connector connector : connectors) {
  26.             try {
  27.                 connector.init();
  28.             } catch (Exception e) {
  29.                 String message = sm.getString(
  30.                         "stxandardService.connector.initFailed", connector);
  31.                 log.error(message, e);
  32.  
  33.                 if (Boolean.getBoolean("org.apache.catalina.startup.EXIT_ON_INIT_FAILURE")) {
  34.                     throw new LifecycleException(message);
  35.                 }
  36.             }
  37.         }
  38.     }
  39. }

#注册到bean

org.apache.catalina.util.LifecycleMBeanBase#initInternal

  1. @Override
  2. protected void initInternal() throws LifecycleException {
  3.     // If oname is not null then registration has already happened via
  4.     // preRegister().
  5.     if (oname == null) {
  6.         mserver = Registry.getRegistry(null, null).getMBeanServer();
  7.  
  8.         oname = register(this, getObjectNameKeyProperties());
  9.     }
  10. }

org.apache.catalina.connector.Connector#initInternal

  1. @Override
  2. protected void initInternal() throws LifecycleException {
  3.  
  4.     super.initInternal();
  5.  
  6.     // Initialize adapter
  7.     adapter = new CoyoteAdapter(this);
  8.     protocolHandler.setAdapter(adapter);
  9.  
  10.     // Make sure parseBodyMethodsSet has a default
  11.     if (null == parseBodyMethodsSet) {
  12.         setParseBodyMethods(getParseBodyMethods());
  13.     }
  14.  
  15.     if (protocolHandler.isAprRequired() && !AprLifecycleListener.isInstanceCreated()) {
  16.         throw new LifecycleException(sm.getString("coyoteConnector.protocolHandlerNoAprListener",
  17.                 getProtocolHandlerClassName()));
  18.     }
  19.     if (protocolHandler.isAprRequired() && !AprLifecycleListener.isAprAvailable()) {
  20.         throw new LifecycleException(sm.getString("coyoteConnector.protocolHandlerNoAprLibrary",
  21.                 getProtocolHandlerClassName()));
  22.     }
  23.     if (AprLifecycleListener.isAprAvailable() && AprLifecycleListener.getUseOpenSSL() &&
  24.             protocolHandler instanceof AbstractHttp11JsseProtocol) {
  25.         AbstractHttp11JsseProtocol<?> jsseProtocolHandler =
  26.                 (AbstractHttp11JsseProtocol<?>) protocolHandler;
  27.         if (jsseProtocolHandler.isSSLEnabled() &&
  28.                 jsseProtocolHandler.getSslImplementationName() == null) {
  29.             // OpenSSL is compatible with the JSSE configuration, so use it if APR is available
  30.             jsseProtocolHandler.setSslImplementationName(OpenSSLImplementation.class.getName());
  31.         }
  32.     }
  33.  
  34.     try {
  35.         protocolHandler.init();
  36.     } catch (Exception e) {
  37.         throw new LifecycleException(
  38.                 sm.getString("coyoteConnector.protocolHandlerInitializationFailed"), e);
  39.     }
  40. }

#初始化httpnio

org.apache.coyote.http11.AbstractHttp11Protocol#init

  1. @Override
  2. public void init() throws Exception {
  3.     // Upgrade protocols have to be configured first since the endpoint
  4.     // init (triggered via super.init() below) uses this list to configure
  5.     // the list of ALPN protocols to advertise
  6.     for (UpgradeProtocol upgradeProtocol : upgradeProtocols) {
  7.         configureUpgradeProtocol(upgradeProtocol);
  8.     }
  9.  
  10.     super.init();
  11.  
  12.     // Set the Http11Protocol (i.e. this) for any upgrade protocols once
  13.     // this has completed initialisation as the upgrade protocols may expect this
  14.     // to be initialised when the call is made
  15.     for (UpgradeProtocol upgradeProtocol : upgradeProtocols) {
  16.         if (upgradeProtocol instanceof Http2Protocol) {
  17.             ((Http2Protocol) upgradeProtocol).setHttp11Protocol(this);
  18.         }
  19.     }
  20. }
shutdownhook关闭钩子（优雅关闭） 
  1. protected class CatalinaShutdownHook extends Thread {
  2.  
  3.     @Override
  4.     public void run() {
  5.         try {
  6.             if (getServer() != null) {
  7.                 Catalina.this.stop();
  8.             }
  9.         } catch (Throwable ex) {
  10.             ExceptionUtils.handleThrowable(ex);
  11.             log.error(sm.getString("catalina.shutdownHookFail"), ex);
  12.         } finally {
  13.             // If JULI is used, shut JULI down *after* the server shuts down
  14.             // so log messages aren't lost
  15.             LogManager logManager = LogManager.getLogManager();
  16.             if (logManager instanceof ClassLoaderLogManager) {
  17.                 ((ClassLoaderLogManager) logManager).shutdown();
  18.             }
  19.         }
  20.     }
  21. public void load() {
  22.  
  23.     if (loaded) {
  24.         return;
  25.     }
  26.     loaded = true;
  27.  
  28.     long t1 = System.nanoTime();
  29.  
  30.     initDirs();
  31.  
  32.     // Before digester - it may be needed
  33.     initNaming();
  34.  
  35.     // Set configuration source
  36.     ConfigFileLoader.setSource(new CatalinaBaseConfigurationSource(Bootstrap.getCatalinaBaseFile(), getConfigFile()));
  37.     File file = configFile();
  38.  
  39.     // 创建解析器(核心方法)
  40.     Digester digester = createStartDigester();
  41.  
  42.     try (ConfigurationSource.Resource resource = ConfigFileLoader.getSource().getServerXml()) {
  43.         InputStream inputStream = resource.getInputStream();
  44.         InputSource inputSource = new InputSource(resource.getURI().toURL().toString());
  45.         inputSource.setByteStream(inputStream);
  46.         digester.push(this);
  47.         digester.parse(inputSource);
  48.     } catch (Exception e) {
  49.         log.warn(sm.getString("catalina.configFail", file.getAbsolutePath()), e);
  50.         if (file.exists() && !file.canRead()) {
  51.             log.warn(sm.getString("catalina.incorrectPermissions"));
  52.         }
  53.         return;
  54.     }
  55.     //进行双向绑定 绑定到server中，而catalina也可以获取到server。
  56.     getServer().setCatalina(this);
  57.     getServer().setCatalinaHome(Bootstrap.getCatalinaHomeFile());
  58.     getServer().setCatalinaBase(Bootstrap.getCatalinaBaseFile());
  59.  
  60.     // Stream redirection
  61.     initStreams();
  62.  
  63.     // Start the new server
  64.     try {
  65.         //初始化服务操作
  66.         getServer().init();
  67.     } catch (LifecycleException e) {
  68.         if (Boolean.getBoolean("org.apache.catalina.startup.EXIT_ON_INIT_FAILURE")) {
  69.             throw new java.lang.Error(e);
  70.         } else {
  71.             log.error(sm.getString("catalina.initError"), e);
  72.         }
  73.     }
  74.  
  75.     long t2 = System.nanoTime();
  76.     if(log.isInfoEnabled()) {
  77.         log.info(sm.getString("catalina.init", Long.valueOf((t2 - t1) / 1000000)));
  78.     }
  79. }}

org.apache.catalina.startup.Catalina#initNaming

  1. protected void initNaming() {
  2.     // Setting additional variables
  3.     if (!useNaming) {
  4.         log.info(sm.getString("catalina.noNaming"));
  5.         System.setProperty("catalina.useNaming", "false");
  6.     } else {
  7.         //设置系统属性catalina.useNaming 为true
  8.         System.setProperty("catalina.useNaming", "true");
  9.         String value = "org.apache.naming";
  10.         String oldValue =
  11.             System.getProperty(javax.naming.Context.URL_PKG_PREFIXES);
  12.         //如果系统属性中该值已存在 则将新值：老值这样拼上;
  13.         if (oldValue != null) {
  14.             value = value + ":" + oldValue;
  15.         }
  16.         //设置java.naming.factory.url.pkgs 为 org.apache.naming
  17.         System.setProperty(javax.naming.Context.URL_PKG_PREFIXES, value);
  18.         if( log.isDebugEnabled() ) {
  19.             log.debug("Setting naming prefix=" + value);
  20.         }
  21.         //获取系统属性java.naming.factory.initial
  22.         value = System.getProperty
  23.             (javax.naming.Context.INITIAL_CONTEXT_FACTORY);
  24.         if (value == null) {
  25.             System.setProperty
  26.                 (javax.naming.Context.INITIAL_CONTEXT_FACTORY,
  27.                  "org.apache.naming.java.javaURLContextFactory");
  28.         } else {
  29.             log.debug( "INITIAL_CONTEXT_FACTORY already set " + value );
  30.         }
  31.     }
  32. }

所有的生命期都在lifecyclebase进行管理

org.apache.catalina.util.LifecycleBase#init

  1. @Override
  2. public final synchronized void init() throws LifecycleException {
  3.     if (!state.equals(LifecycleState.NEW)) {
  4.         invalidTransition(Lifecycle.BEFORE_INIT_EVENT);
  5.     }
  6.  
  7.     try {
  8.         //设置生命周期状态
  9.         setStateInternal(LifecycleState.INITIALIZING, null, false);
  10.         initInternal();
  11.         setStateInternal(LifecycleState.INITIALIZED, null, false);
  12.     } catch (Throwable t) {
  13.         handleSubClassException(t, "lifecycleBase.initFail", toString());
  14.     }
  15. }

位置：org.apache.catalina.connector.Connector#setProtocol（用于设置协议 tomcat高版本默认为nio，而协议为http 1.1）

  1. public void setProtocol(String protocol) {
  2.  
  3.     boolean aprConnector = AprLifecycleListener.isAprAvailable() &&
  4.             AprLifecycleListener.getUseAprConnector();
  5.  
  6.     if ("HTTP/1.1".equals(protocol) || protocol == null) {
  7.         if (aprConnector) {
  8.             setProtocolHandlerClassName("org.apache.coyote.http11.Http11AprProtocol");
  9.         } else {
  10.             setProtocolHandlerClassName("org.apache.coyote.http11.Http11NioProtocol");
  11.         }
  12.     } else if ("AJP/1.3".equals(protocol)) {
  13.         if (aprConnector) {
  14.             setProtocolHandlerClassName("org.apache.coyote.ajp.AjpAprProtocol");
  15.         } else {
  16.             setProtocolHandlerClassName("org.apache.coyote.ajp.AjpNioProtocol");
  17.         }
  18.     } else {
  19.         setProtocolHandlerClassName(protocol);
  20.     }
  21. }

最终进入方法：org.apache.catalina.startup.Catalina#start ，那么整个启动就完毕了。但是要注意下面的这个await(); ，启动到这里就一直阻塞了，每隔10秒就检测一次，当stopAwait为true时，线程才结束。

  1. /**
  2.  * Start a new server instance.
  3.  */
  4. public void start() {
  5.  
  6.     if (getServer() == null) {
  7.         load();
  8.     }
  9.  
  10.     if (getServer() == null) {
  11.         log.fatal("Cannot start server. Server instance is not configured.");
  12.         return;
  13.     }
  14.  
  15.     long t1 = System.nanoTime();
  16.  
  17.     // Start the new server 启动服务
  18.     try {
  19.         getServer().start();
  20.     } catch (LifecycleException e) {
  21.         log.fatal(sm.getString("catalina.serverStartFail"), e);
  22.         try {
  23.             getServer().destroy();
  24.         } catch (LifecycleException e1) {
  25.             log.debug("destroy() failed for failed Server ", e1);
  26.         }
  27.         return;
  28.     }
  29.  
  30.     long t2 = System.nanoTime();
  31.     if(log.isInfoEnabled()) {
  32.         log.info("Server startup in " + ((t2 - t1) / 1000000) + " ms");
  33.     }
  34.  
  35.     // Register shutdown hook
  36.     if (useShutdownHook) {
  37.         if (shutdownHook == null) {
  38.             shutdownHook = new CatalinaShutdownHook();
  39.         }
  40.         Runtime.getRuntime().addShutdownHook(shutdownHook);
  41.  
  42.         // If JULI is being used, disable JULI's shutdown hook since
  43.         // shutdown hooks run in parallel and log messages may be lost
  44.         // if JULI's hook completes before the CatalinaShutdownHook()
  45.         LogManager logManager = LogManager.getLogManager();
  46.         if (logManager instanceof ClassLoaderLogManager) {
  47.             ((ClassLoaderLogManager) logManager).setUseShutdownHook(
  48.                     false);
  49.         }
  50.     }
  51.     //await就是主线程的守护，否则就直接关闭了
  52.     if (await) {
  53.         await();
  54.         //当上面的结束后，才会执行下面的关闭，如果没有就一直等待中,当关闭线程的时候，不会直接就关闭，因为tomcat使用卫钩子函数，通过这个可以优雅关闭。
  55.         stop();
  56.     }
  57. }

最后

    以上为tomcat启动的核心流程，只挑了一些重点的了解，其实tomcat还有很多非常细节没有涉及到，由于篇幅有限所以，在后续如果需要的时候再标出，还有原因上传gitee上面有需要同步可以拉源码了解。

参考：《Tomcat架构解析》

0de1e48da65595eed4d66d874848bd4d.png

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/天景科技苑/article/detail/741649
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号