Tomcat tomcat = new Tomcat();
        tomcat.setPort(8080);
        //new 出各層容器，并且維護(hù)各層容器的關(guān)系
        tomcat.addWebapp("/","/");
        tomcat.start();
        //阻塞監(jiān)聽端口
        tomcat.getServer().await();

 
    public Context  addWebapp(Host host, String contextPath, String docBase) {
        //通過反射獲得一個監(jiān)聽器  ContextConfig,
        //通過反射得到的一定是LifecycleListener的一個實現(xiàn)類，進(jìn)入getConfigClass得到實現(xiàn)類（org.apache.catalina.startup.ContextConfig）
        LifecycleListener listener = null;
        try {
            Class<?> clazz = Class.forName(getHost().getConfigClass());
            listener = (LifecycleListener) clazz.getConstructor().newInstance();
        } catch (ReflectiveOperationException e) {
            // Wrap in IAE since we can't easily change the method signature to
            // to throw the specific checked exceptions
            throw new IllegalArgumentException(e);
        }
 
        return addWebapp(host, contextPath, docBase, listener);
    }

public Context addWebapp(Host host, String contextPath, String docBase,
            LifecycleListener config) {
 
        silence(host, contextPath);
 
        //獲得一個context容器(StandardContext)
        Context ctx = createContext(host, contextPath);
        ctx.setPath(contextPath);
        ctx.setDocBase(docBase);
 
        if (addDefaultWebXmlToWebapp) {
            ctx.addLifecycleListener(getDefaultWebXmlListener());
        }
 
        ctx.setConfigFile(getWebappConfigFile(docBase, contextPath));
        //把監(jiān)聽器添加到context中去
        ctx.addLifecycleListener(config);
 
        if (addDefaultWebXmlToWebapp && (config instanceof ContextConfig)) {
            // prevent it from looking ( if it finds one - it'll have dup error )
            ((ContextConfig) config).setDefaultWebXml(noDefaultWebXmlPath());
        }
 
        if (host == null) {
            //getHost會逐層創(chuàng)建容器，并維護(hù)容器父子關(guān)系
            getHost().addChild(ctx);
        } else {
            host.addChild(ctx);
        }
 
        return ctx;
    }

  public Host getHost() {
        //將每一層的容器都new 出來
        Engine engine = getEngine();
        if (engine.findChildren().length > 0) {
            return (Host) engine.findChildren()[0];
        }
 
        Host host = new StandardHost();
        host.setName(hostname);
        //維護(hù)tomcat中的父子容器
        getEngine().addChild(host);
        return host;
    }

  @Override
    public void addChild(Container child) {
        if (Globals.IS_SECURITY_ENABLED) {
            PrivilegedAction<Void> dp =
                new PrivilegedAddChild(child);
            AccessController.doPrivileged(dp);
        } else {
            //這里的child 參數(shù)是 context 容器
            addChildInternal(child);
        }
    }

 private void addChildInternal(Container child) {
 
        if( log.isDebugEnabled() )
            log.debug("Add child " + child + " " + this);
        synchronized(children) {
            if (children.get(child.getName()) != null)
                throw new IllegalArgumentException("addChild:  Child name '" +
                                                   child.getName() +
                                                   "' is not unique");
            child.setParent(this);  // May throw IAE
            children.put(child.getName(), child);
    }

  public void start() throws LifecycleException {
        //防止server容器沒有創(chuàng)建
        getServer();
        //獲得connector容器，并且將得到的connector容器設(shè)置到service容器中
        getConnector();
        //這里的start的實現(xiàn)是在 LifecycleBase類中實現(xiàn)
        //LifecycleBase方法是一個模板方法，在tomcat啟動流程中非常關(guān)鍵
        server.start();
    }

protected void startInternal() throws LifecycleException {
 
        fireLifecycleEvent(CONFIGURE_START_EVENT, null);
        setState(LifecycleState.STARTING);
 
        globalNamingResources.start();
 
        // Start our defined Services
        synchronized (servicesLock) {
            //啟動 service容器，一個tomcat中可以配置多個service容器，每個service容器都對應(yīng)這我們的一個服務(wù)應(yīng)用
            for (Service service : services) {
                //對應(yīng) StandardService.startInternal()
                service.start();
            }
        }
    }

 // Start our child containers, if any
        //在addWwbapp的流程中 addChild方法中加入的，所以這里需要找出來
        //這里找出來的就是 context 容器
        Container children[] = findChildren();
        List<Future<Void>> results = new ArrayList<>();
        for (Container child : children) {
            //通過線程池 異步的方式啟動線程池 開始啟動 context容器，進(jìn)入new StartChild
            results.add(startStopExecutor.submit(new StartChild(child)));
        }

    private static class StartChild implements Callable<Void> {
 
        private Container child;
 
        public StartChild(Container child) {
            this.child = child;
        }
 
        @Override
        public Void call() throws LifecycleException {
            //開始啟動context，實際調(diào)用 StandardContext.startInternal()
            child.start();
            return null;
        }
    }

   protected void fireLifecycleEvent(String type, Object data) {
        LifecycleEvent event = new LifecycleEvent(this, type, data);
        //lifecycleListeners 在addwebapp方法的第一步中，設(shè)置的監(jiān)聽的 contextConfig對象
        for (LifecycleListener listener : lifecycleListeners) {
            //這里調(diào)用的是 contextConfig的lifecycleEvent()方法
            listener.lifecycleEvent(event);
        }
    }

public void lifecycleEvent(LifecycleEvent event) {
 
        // Identify the context we are associated with
        try {
            context = (Context) event.getLifecycle();
        } catch (ClassCastException e) {
            log.error(sm.getString("contextConfig.cce", event.getLifecycle()), e);
            return;
        }
 
        // Process the event that has occurred
        if (event.getType().equals(Lifecycle.CONFIGURE_START_EVENT)) {
            //完成web.xml的內(nèi)容解析
            configureStart();
        } else if (event.getType().equals(Lifecycle.BEFORE_START_EVENT)) {
            beforeStart();
        } else if (event.getType().equals(Lifecycle.AFTER_START_EVENT)) {
            // Restore docBase for management tools
            if (originalDocBase != null) {
                context.setDocBase(originalDocBase);
            }
        } else if (event.getType().equals(Lifecycle.CONFIGURE_STOP_EVENT)) {
            configureStop();
        } else if (event.getType().equals(Lifecycle.AFTER_INIT_EVENT)) {
            init();
        } else if (event.getType().equals(Lifecycle.AFTER_DESTROY_EVENT)) {
            destroy();
        }
 
    }

public boolean loadOnStartup(Container children[]) {
 
        // Collect "load on startup" servlets that need to be initialized
        TreeMap<Integer, ArrayList<Wrapper>> map = new TreeMap<>();
        for (Container child : children) {
            //這里的 Wrapper就是 我們前面封裝的 servlet
            Wrapper wrapper = (Wrapper) child;
            int loadOnStartup = wrapper.getLoadOnStartup();
            if (loadOnStartup < 0) {
                continue;
            }
            Integer key = Integer.valueOf(loadOnStartup);
            ArrayList<Wrapper> list = map.get(key);
            if (list == null) {
                list = new ArrayList<>();
                map.put(key, list);
            }
            list.add(wrapper);
        }
 
        // Load the collected "load on startup" servlets
        for (ArrayList<Wrapper> list : map.values()) {
            for (Wrapper wrapper : list) {
                try {
                    //通過 load 方法  最終會調(diào)用 servlet的init方法
                    wrapper.load();
                } catch (ServletException e) {
                    getLogger().error(sm.getString("standardContext.loadOnStartup.loadException",
                          getName(), wrapper.getName()), StandardWrapper.getRootCause(e));
                    // NOTE: load errors (including a servlet that throws
                    // UnavailableException from the init() method) are NOT
                    // fatal to application startup
                    // unless failCtxIfServletStartFails="true" is specified
                    if(getComputedFailCtxIfServletStartFails()) {
                        return false;
                    }
                }
            }
        }
        return true;
 
    }