eval exec "\"$_RUNJDB\"" "\"$CATALINA_LOGGING_CONFIG\"" $LOGGING_MANAGER "$JAVA_OPTS" "$CATALINA_OPTS" \
        -D$ENDORSED_PROP="$JAVA_ENDORSED_DIRS" \
        -classpath "$CLASSPATH" \
        -sourcepath "$CATALINA_HOME"/../../java \
        -Dcatalina.base="$CATALINA_BASE" \
        -Dcatalina.home="$CATALINA_HOME" \
        -Djava.io.tmpdir="$CATALINA_TMPDIR" \
        //這里會運行Bootstrap的main方法 并傳入start參數(shù)
        org.apache.catalina.startup.Bootstrap "$@" start
    fi

//全局變量 用于保存Bootstrap實例
private static volatile Bootstrap daemon = null;
//全局變量 用于保存Catalina對象
private Object catalinaDaemon = null;
public static void main(String args[]) {
        synchronized (daemonLock) {
            if (daemon == null) {
                // Don't set daemon until init() has completed
                Bootstrap bootstrap = new Bootstrap();
                try {
                    //這里 構(gòu)建Catalina對象并賦值給全局變量catalinaDaemon	
                    bootstrap.init();
                } catch (Throwable t) {
                   ...
                }
                //這里初始化了全局變量
                daemon = bootstrap;
            } else {
               ...
            }
			try {
	             ...
	            if (command.equals("start")) {
	                daemon.setAwait(true);
	                //本質(zhì)是調(diào)用了Catalina對象的load方法
	                daemon.load(args);
	                //本質(zhì)上是調(diào)用了Catalina的start方法
	                daemon.start();
	                ...
	            } 
	        } catch (Throwable t) {
	                 ...
	        }
        ...
 }
 //構(gòu)建Catalina對象并賦值給全局變量catalinaDaemon	
 public void init() throws Exception {
  		...
  		//通過反射構(gòu)建Catalina對象
        Class<?> startupClass = catalinaLoader.loadClass("org.apache.catalina.startup.Catalina");
        Object startupInstance = startupClass.getConstructor().newInstance();
		...
		//這里把Catalina對象賦予了全局變量catalinaDaemon
        catalinaDaemon = startupInstance;
 }
//本質(zhì)是調(diào)用了Catalina對象的load方法
private void load(String[] arguments) throws Exception {
        // Call the load() method
        String methodName = "load";
        ...
        Method method =
            catalinaDaemon.getClass().getMethod(methodName, paramTypes);
        //這里就是調(diào)用了Catalina對象的load方法
        method.invoke(catalinaDaemon, param);
}
//本質(zhì)上是調(diào)用了Catalina的start方法
public void start() throws Exception {
      Method method = catalinaDaemon.getClass().getMethod("start", (Class [])null);
      method.invoke(catalinaDaemon, (Object [])null);
}

//全局變量Server對象 該對象通過解析server.xml生成
protected Server server = null;
public void load() {
        ...
        // Parse main server.xml
        // 解析server.xml文件 初始化server對象
        parseServerXml(true);
        Server s = getServer()
        ...
        // Start the new server
        try {
            getServer().init();
        } catch (LifecycleException e) {
           ...
        }
       ...
    }

//本質(zhì)上就是調(diào)用server的start方法
public void start() {
        ...
        // Start the new server
        try {
            getServer().start();
        } catch (LifecycleException e) {
           ...
        }
         ...
    }
//返回全局變量server
public Server getServer() {
        return server;
    }    

public abstract class LifecycleBase implements Lifecycle {
	//抽象模板類提供的公共方法
	public final synchronized void init() throws LifecycleException {
        if (!state.equals(LifecycleState.NEW)) {
            invalidTransition(Lifecycle.BEFORE_INIT_EVENT);
        }
        try {
            setStateInternal(LifecycleState.INITIALIZING, null, false);
            //該方法是一個抽象方法由子類完成實現(xiàn)
            //server類的實現(xiàn)方式  就是便利其內(nèi)部的sercie對象 挨個調(diào)用其init方法
            //service類的實現(xiàn)方法 就是調(diào)用engine的 init方法
            //engine的實現(xiàn)方法 就是便利其內(nèi)部的host對象 挨個調(diào)用其init方法
            //以此類推。。。
            initInternal();
            //這里會發(fā)生狀態(tài)變更 防止重復init用的
            setStateInternal(LifecycleState.INITIALIZED, null, false);
        } catch (Throwable t) {
            handleSubClassException(t, "lifecycleBase.initFail", toString());
        }
    }
    //抽象模板類提供的公共方法
	public final synchronized void start() throws LifecycleException {
		if (state.equals(LifecycleState.NEW)) {
		    //start方法中會先執(zhí)行init方法
            init();
        } else if (state.equals(LifecycleState.FAILED)) {
             ...
        } else if (!state.equals(LifecycleState.INITIALIZED) &&
             ...
        }
        ...
        try {
            setStateInternal(LifecycleState.STARTING_PREP, null, false);
            //該方法是一個抽象方法由子類完成實現(xiàn)
            //server類的實現(xiàn)方式 就是便利其內(nèi)部的sercie對象 挨個調(diào)用其start方法
            //service類的實現(xiàn)方法 就是調(diào)用engine的 start方法
            //engine的實現(xiàn)方法 就是便利其內(nèi)部的host對象 挨個調(diào)用其start方法
            //以此類推。。。
            startInternal();
            ...
        } catch (Throwable t) {
           ...
        }
    }
	//子類實現(xiàn)
	protected abstract void initInternal() throws LifecycleException;
    //子類實現(xiàn)
    protected abstract void startInternal() throws LifecycleException;
}   

public class Tomcat {
	//全局變量
	protected Server server;
	//啟動方法
	public void start() throws LifecycleException {
        getServer();
        //本質(zhì)是server的start方法
        server.start();
    }
    //重點在后邊的這幾個方法
	//獲取server
	public Server getServer() {
		...
		if (server != null) {
            return server;
        }
        //這里直接new對象了 不像Catalina那樣需要解析server.xml文件
        server = new StandardServer();
        initBaseDir();
        ...
        //順便為其創(chuàng)建了一個service對象
        Service service = new StandardService();
        service.setName("Tomcat");
        server.addService(service);
        return server;
    }
	//獲取service 內(nèi)部調(diào)用了getServer 一樣的道理 沒有就new
	public Service getService() {
        return getServer().findServices()[0];
    }
	//獲取引擎 一樣的邏輯 沒有就new
	public Engine getEngine() {
        Service service = getServer().findServices()[0];
        if (service.getContainer() != null) {
            return service.getContainer();
        }
        Engine engine = new StandardEngine();
        engine.setName( "Tomcat" );
        engine.setDefaultHost(hostname);
        engine.setRealm(createDefaultRealm());
        service.setContainer(engine);
        return engine;
    }
	//獲取host 同上沒有就new
	public Host getHost() {
        Engine engine = getEngine();
        if (engine.findChildren().length > 0) {
            return (Host) engine.findChildren()[0];
        }
        Host host = new StandardHost();
        host.setName(hostname);
        getEngine().addChild(host);
        return host;
    }
}

public class ServletWebServerApplicationContext extends GenericWebApplicationContext
		implements ConfigurableWebServerApplicationContext {
	//重寫了父類的方法
	@Override
	protected void onRefresh() {
		super.onRefresh();
		try {
		    //重點在這里
			createWebServer();
		}
		....
	}
	//創(chuàng)建WebServer，其內(nèi)部封裝了Tomcat對象
	private void createWebServer() {
		WebServer webServer = this.webServer;
		//這里取Tomcat容器對象 首次是取不到的
		ServletContext servletContext = getServletContext();
		if (webServer == null && servletContext == null) {
			//獲取工廠對象 該對象是自動裝配中裝配的 默認是TomcatServletWebServerFactory
			ServletWebServerFactory factory = getWebServerFactory();
			//通過工廠創(chuàng)建WebServer對象，WebServer對象創(chuàng)建完Tomcat就會啟動 所以重點跟下這里
			this.webServer = factory.getWebServer(getSelfInitializer());
			getBeanFactory().registerSingleton("webServerGracefulShutdown",
					new WebServerGracefulShutdownLifecycle(this.webServer));
			getBeanFactory().registerSingleton("webServerStartStop",
					new WebServerStartStopLifecycle(this, this.webServer));
		}
		else if (servletContext != null) {
			...
		}
		initPropertySources();
	}
}

public class TomcatServletWebServerFactory extends AbstractServletWebServerFactory
		implements ConfigurableTomcatWebServerFactory, ResourceLoaderAware {
	//主要方法	
	@Override
	public WebServer getWebServer(ServletContextInitializer... initializers) {
		if (this.disableMBeanRegistry) {
			Registry.disableRegistry();
		}
		//內(nèi)嵌Tomcat對象
		Tomcat tomcat = new Tomcat();
		File baseDir = (this.baseDirectory != null) ? this.baseDirectory : createTempDir("tomcat");
		tomcat.setBaseDir(baseDir.getAbsolutePath());
		Connector connector = new Connector(this.protocol);
		connector.setThrowOnFailure(true);
		//這里可以知道 其創(chuàng)建了server對象和service對象 并為service對象設(shè)置了connector 
		tomcat.getService().addConnector(connector);
		customizeConnector(connector);
		tomcat.setConnector(connector);
		//這里可以知道 其創(chuàng)建了engine對象和host對象
		tomcat.getHost().setAutoDeploy(false);
		configureEngine(tomcat.getEngine());
		for (Connector additionalConnector : this.additionalTomcatConnectors) {
			tomcat.getService().addConnector(additionalConnector);
		}
		//這里創(chuàng)建了Servlet容器
		prepareContext(tomcat.getHost(), initializers);
		return getTomcatWebServer(tomcat);
	}
	//創(chuàng)建Servlet容器
	protected void prepareContext(Host host, ServletContextInitializer[] initializers) {
		File documentRoot = getValidDocumentRoot();
		//直接new了一個容器 該類是StandardContext的子類
		TomcatEmbeddedContext context = new TomcatEmbeddedContext();
		if (documentRoot != null) {
			context.setResources(new LoaderHidingResourceRoot(context));
		}
		...
		ServletContextInitializer[] initializersToUse = mergeInitializers(initializers);
		//將容器放入host對象中
		host.addChild(context);
		configureContext(context, initializersToUse);
		postProcessContext(context);
	}
	//構(gòu)造TomcatWebServer對象將Tomcat對象封裝其中
	protected TomcatWebServer getTomcatWebServer(Tomcat tomcat) {
		return new TomcatWebServer(tomcat, getPort() >= 0, getShutdown());
	}
}

public class TomcatWebServer implements WebServer {
	//用于封裝Tomcat對象
	private final Tomcat tomcat;
	public TomcatWebServer(Tomcat tomcat, boolean autoStart, Shutdown shutdown) {
		Assert.notNull(tomcat, "Tomcat Server must not be null");
		//初始化Tomcat對象
		this.tomcat = tomcat;
		this.autoStart = autoStart;
		this.gracefulShutdown = (shutdown == Shutdown.GRACEFUL) ? new GracefulShutdown(tomcat) : null;
		//重點看這里 這里啟動了Tomcat
		initialize();
	}
	//啟動了Tomcat
	private void initialize() throws WebServerException {
		logger.info("Tomcat initialized with port(s): " + getPortsDescription(false));
		synchronized (this.monitor) {
			try {
				...
				// Start the server to trigger initialization listeners
				this.tomcat.start();
				...
			}
			catch (Exception ex) {
				...
			}
		}
	}
}

public interface ServletContext {
	public ServletRegistration.Dynamic addServlet(String servletName, String className);
    public ServletRegistration.Dynamic addServlet(String servletName, Servlet servlet);
    public ServletRegistration.Dynamic addServlet(String servletName,
            Class<? extends Servlet> servletClass);
}

public class TomcatServletWebServerFactory extends AbstractServletWebServerFactory
		implements ConfigurableTomcatWebServerFactory, ResourceLoaderAware {
	//創(chuàng)建Servlet容器
	protected void prepareContext(Host host, ServletContextInitializer[] initializers) {
		File documentRoot = getValidDocumentRoot();
		//直接new了一個容器 該類是StandardContext的子類
		TomcatEmbeddedContext context = new TomcatEmbeddedContext();
		if (documentRoot != null) {
			context.setResources(new LoaderHidingResourceRoot(context));
		}
		...
		ServletContextInitializer[] initializersToUse = mergeInitializers(initializers);
		//將容器放入host對象中
		host.addChild(context);
		//這個方法之前沒根 這次下這個方法
		configureContext(context, initializersToUse);
		postProcessContext(context);
	}
	protected void configureContext(Context context, ServletContextInitializer[] initializers) {
		//創(chuàng)建了ServletContainerInitializer的實現(xiàn)類
		TomcatStarter starter = new TomcatStarter(initializers);
		...
		//這里直接將其放入到了容器中
		context.addServletContainerInitializer(starter, NO_CLASSES);
		...
	}
}

public class StandardContext extends ContainerBase implements Context, NotificationEmitter {
	//內(nèi)部有一個集合 用于保存所有ServletContainerInitializer的實現(xiàn)類
    private Map<ServletContainerInitializer,Set<Class<?>>> initializers =
        new LinkedHashMap<>();
	//還記得這個方法嗎TomcatEmbeddedContext就是通過該方法將TomcatStarter添加進來的
	public void addServletContainerInitializer(
            ServletContainerInitializer sci, Set<Class<?>> classes) {
        initializers.put(sci, classes);
    }
	//Tomcat啟動時會執(zhí)行該方法 這個方法巨長無比 我只把關(guān)鍵的保留了
	protected synchronized void startInternal() throws LifecycleException {
	    //便利集合
		for (Map.Entry<ServletContainerInitializer, Set<Class<?>>> entry :
                initializers.entrySet()) {
                try {
                    //集合中的key就是ServletContainerInitializer的實現(xiàn)類 這里調(diào)用了onStartup方法
                    entry.getKey().onStartup(entry.getValue(),
                    		//最后看下getServletContext方法，看看容器的裝飾類到底是什么
                            getServletContext());
                } catch (ServletException e) {
                    log.error(sm.getString("standardContext.sciFail"), e);
                    ok = false;
                    break;
                }
        }
   }
   //這里可以知道容器最終把自己封裝到了ApplicationContext對象中，
   //最終將ApplicationContext對象暴露給ServletContainerInitializer實現(xiàn)類
   public ServletContext getServletContext() {
        if (context == null) {
            context = new ApplicationContext(this);
            if (altDDName != null)
                context.setAttribute(Globals.ALT_DD_ATTR,altDDName);
        }
        return context.getFacade();
    }
}

class TomcatStarter implements ServletContainerInitializer {
	//一堆ServletContextInitializer接口的實現(xiàn)類
	private final ServletContextInitializer[] initializers;
	//構(gòu)造器 初始化內(nèi)部的initializers屬性
	TomcatStarter(ServletContextInitializer[] initializers) {
		this.initializers = initializers;
	}
	//這個方法里沒有任何servlet的添加操作，而是便利了initializers，并執(zhí)行initializers每一個實例的onStartup方法，將servletContext當入?yún)魅肫渲?
	@Override
	public void onStartup(Set<Class<?>> classes, ServletContext servletContext) throws ServletException {
		try {
			for (ServletContextInitializer initializer : this.initializers) {
				initializer.onStartup(servletContext);
			}
		}
		catch (Exception ex) {
			....
		}
	}
}

public class ServletWebServerApplicationContext extends GenericWebApplicationContext
		implements ConfigurableWebServerApplicationContext {
	//最終這個私有方法會被調(diào)用，可以看出如果TomcatStarter中的onStartup方法能調(diào)用到該方法，上述說的spirng目的就達成了
	private void selfInitialize(ServletContext servletContext) throws ServletException {
		prepareWebApplicationContext(servletContext);
		registerApplicationScope(servletContext);
		WebApplicationContextUtils.registerEnvironmentBeans(getBeanFactory(), servletContext);
		//這里拿到容器中所有實現(xiàn)了ServletContextInitializer接口的bean并依次執(zhí)行其onStartup方法 入?yún)⑹莝ervletContext
		for (ServletContextInitializer beans : getServletContextInitializerBeans()) {
			beans.onStartup(servletContext);
		}
	}
	//ServletContextInitializer本身是一個@FunctionalInterface
	//這里將上述的私有方法封裝成了一個ServletContextInitializer實例 很感慨既然還能這樣干
	private org.springframework.boot.web.servlet.ServletContextInitializer getSelfInitializer() {
		return this::selfInitialize;
	}	
	//還記得這個方法嗎，這里通過factory完成了WebServer的創(chuàng)建，也就是tomcat啟動的位置
	private void createWebServer() {
		WebServer webServer = this.webServer;
		ServletContext servletContext = getServletContext();
		if (webServer == null && servletContext == null) {
			ServletWebServerFactory factory = getWebServerFactory();
			//這里將ServletContextInitializer實例傳入到了TomcatServletWebServerFactory中
			this.webServer = factory.getWebServer(getSelfInitializer());
			...
		}
		....
	}
}

public class TomcatServletWebServerFactory extends AbstractServletWebServerFactory
		implements ConfigurableTomcatWebServerFactory, ResourceLoaderAware {
	//這里ServletContextInitializer實例被傳入
	public WebServer getWebServer(ServletContextInitializer... initializers) {
		...
		//被傳入到該方法
		prepareContext(tomcat.getHost(), initializers);
		return getTomcatWebServer(tomcat);
	}
	protected void prepareContext(Host host, ServletContextInitializer[] initializers) {
		//這里做了依次封裝 之前的ServletContextInitializer實例就在其中
		ServletContextInitializer[] initializersToUse = mergeInitializers(initializers);
		//根這里
		configureContext(context, initializersToUse);
		postProcessContext(context);
	}
	//做了一層擴展
	protected final ServletContextInitializer[] mergeInitializers(ServletContextInitializer... initializers) {
		List<ServletContextInitializer> mergedInitializers = new ArrayList<>();
		mergedInitializers.add((servletContext) -> this.initParameters.forEach(servletContext::setInitParameter));
		mergedInitializers.add(new SessionConfiguringInitializer(this.session));
		//被傳入到mergedInitializers集合中
		mergedInitializers.addAll(Arrays.asList(initializers));
		mergedInitializers.addAll(this.initializers);
		//集合轉(zhuǎn)數(shù)組
		return mergedInitializers.toArray(new ServletContextInitializer[0]);
	}
	//最終會將ServletContextInitializer傳入TomcatStarter的構(gòu)造函數(shù)，和之前說的完全對應(yīng)上了
	protected void configureContext(Context context, ServletContextInitializer[] initializers) {
		TomcatStarter starter = new TomcatStarter(initializers);
		...
	}
}

...省略注解
public class DispatcherServletAutoConfiguration {
	...省略注解
	protected static class DispatcherServletConfiguration {
		//這里創(chuàng)建了DispatcherServlet類
		@Bean(name = DEFAULT_DISPATCHER_SERVLET_BEAN_NAME)
		public DispatcherServlet dispatcherServlet(WebMvcProperties webMvcProperties) {
			...省略DispatcherServlet構(gòu)造內(nèi)容
			return dispatcherServlet;
		}
		...
		...省略注解
		protected static class DispatcherServletRegistrationConfiguration {
			...省略注解
			//重點是這個類，上邊的DispatcherServlet會被傳入到該類中，最終由該類完成DispatcherServlet向Tomcat容器的注冊
			public DispatcherServletRegistrationBean dispatcherServletRegistration(DispatcherServlet dispatcherServlet,
					WebMvcProperties webMvcProperties, ObjectProvider<MultipartConfigElement> multipartConfig) {
				DispatcherServletRegistrationBean registration = new DispatcherServletRegistrationBean(dispatcherServlet,
					webMvcProperties.getServlet().getPath());
			registration.setName(DEFAULT_DISPATCHER_SERVLET_BEAN_NAME);
			registration.setLoadOnStartup(webMvcProperties.getServlet().getLoadOnStartup());
			multipartConfig.ifAvailable(registration::setMultipartConfig);
			return registration;
			}
		}
	}
}

public abstract class RegistrationBean implements ServletContextInitializer, Ordered {
	public final void onStartup(ServletContext servletContext) throws ServletException {
		String description = getDescription();
		if (!isEnabled()) {
			logger.info(StringUtils.capitalize(description) + " was not registered (disabled)");
			return;
		}
		//根這個方法 該方法由子類DynamicRegistrationBean實現(xiàn)
		register(description, servletContext);
	}
}

public abstract class DynamicRegistrationBean<D extends Registration.Dynamic> extends RegistrationBean {
	protected final void register(String description, ServletContext servletContext) {
		//servlet注冊在這里完成 該方法由子類ServletRegistrationBean實現(xiàn)
		//servlet注冊完后會返回一個registration對象，用于完成servlet-mapping的配置
		D registration = addRegistration(description, servletContext);
		if (registration == null) {
			logger.info(StringUtils.capitalize(description) + " was not registered (possibly already registered?)");
			return;
		}
		//servlet的mapping配置在這里完成 該方法由子類ServletRegistrationBean實現(xiàn)
		configure(registration);
	}
}

public class ServletRegistrationBean<T extends Servlet> extends DynamicRegistrationBean<ServletRegistration.Dynamic> {
	//這里可以看到servletContext.addServlet方法終于被調(diào)用了
	@Override
	protected ServletRegistration.Dynamic addRegistration(String description, ServletContext servletContext) {
		String name = getServletName();
		//this.servlet就是DispatcherServlet
		return servletContext.addServlet(name, this.servlet);
	}
	//這里來配置servlet-mapping
	@Override
	protected void configure(ServletRegistration.Dynamic registration) {
		super.configure(registration);
		String[] urlMapping = StringUtils.toStringArray(this.urlMappings);
		if (urlMapping.length == 0 && this.alwaysMapUrl) {
			urlMapping = DEFAULT_MAPPINGS;
		}
		if (!ObjectUtils.isEmpty(urlMapping)) {
			registration.addMapping(urlMapping);
		}
		registration.setLoadOnStartup(this.loadOnStartup);
		if (this.multipartConfig != null) {
			registration.setMultipartConfig(this.multipartConfig);
		}
	}
}