SpringBoot如何使用内嵌Tomcat问题

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参数
        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 {
                    //这里 构建Catalina对象并赋值给全局变量catalinaDaemon	
                    bootstrap.init();
                } catch (Throwable t) {
                   ...
                }
                //这里初始化了全局变量
                daemon = bootstrap;
            } else {
               ...
            }
			try {
	             ...
	            if (command.equals("start")) {
	                daemon.setAwait(true);
	                //本质是调用了Catalina对象的load方法
	                daemon.load(args);
	                //本质上是调用了Catalina的start方法
	                daemon.start();
	                ...
	            } 
	        } catch (Throwable t) {
	                 ...
	        }
        ...
 }
 //构建Catalina对象并赋值给全局变量catalinaDaemon	
 public void init() throws Exception {
  		...
  		//通过反射构建Catalina对象
        Class<?> startupClass = catalinaLoader.loadClass("org.apache.catalina.startup.Catalina");
        Object startupInstance = startupClass.getConstructor().newInstance();
		...
		//这里把Catalina对象赋予了全局变量catalinaDaemon
        catalinaDaemon = startupInstance;
 }
//本质是调用了Catalina对象的load方法
private void load(String[] arguments) throws Exception {
        // Call the load() method
        String methodName = "load";
        ...
        Method method =
            catalinaDaemon.getClass().getMethod(methodName, paramTypes);
        //这里就是调用了Catalina对象的load方法
        method.invoke(catalinaDaemon, param);
}
//本质上是调用了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) {
           ...
        }
       ...
    }

//本质上就是调用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);
            //该方法是一个抽象方法由子类完成实现
            //server类的实现方式  就是便利其内部的sercie对象 挨个调用其init方法
            //service类的实现方法 就是调用engine的 init方法
            //engine的实现方法 就是便利其内部的host对象 挨个调用其init方法
            //以此类推。。。
            initInternal();
            //这里会发生状态变更 防止重复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方法中会先执行init方法
            init();
        } else if (state.equals(LifecycleState.FAILED)) {
             ...
        } else if (!state.equals(LifecycleState.INITIALIZED) &&
             ...
        }
        ...
        try {
            setStateInternal(LifecycleState.STARTING_PREP, null, false);
            //该方法是一个抽象方法由子类完成实现
            //server类的实现方式 就是便利其内部的sercie对象 挨个调用其start方法
            //service类的实现方法 就是调用engine的 start方法
            //engine的实现方法 就是便利其内部的host对象 挨个调用其start方法
            //以此类推。。。
            startInternal();
            ...
        } catch (Throwable t) {
           ...
        }
    }
	//子类实现
	protected abstract void initInternal() throws LifecycleException;
    //子类实现
    protected abstract void startInternal() throws LifecycleException;
}   

public class Tomcat {
	//全局变量
	protected Server server;
	//启动方法
	public void start() throws LifecycleException {
        getServer();
        //本质是server的start方法
        server.start();
    }
    //重点在后边的这几个方法
	//获取server
	public Server getServer() {
		...
		if (server != null) {
            return server;
        }
        //这里直接new对象了 不像Catalina那样需要解析server.xml文件
        server = new StandardServer();
        initBaseDir();
        ...
        //顺便为其创建了一个service对象
        Service service = new StandardService();
        service.setName("Tomcat");
        server.addService(service);
        return server;
    }
	//获取service 内部调用了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();
		}
		....
	}
	//创建WebServer，其内部封装了Tomcat对象
	private void createWebServer() {
		WebServer webServer = this.webServer;
		//这里取Tomcat容器对象 首次是取不到的
		ServletContext servletContext = getServletContext();
		if (webServer == null && servletContext == null) {
			//获取工厂对象 该对象是自动装配中装配的 默认是TomcatServletWebServerFactory
			ServletWebServerFactory factory = getWebServerFactory();
			//通过工厂创建WebServer对象，WebServer对象创建完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();
		}
		//内嵌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);
		//这里可以知道 其创建了server对象和service对象 并为service对象设置了connector 
		tomcat.getService().addConnector(connector);
		customizeConnector(connector);
		tomcat.setConnector(connector);
		//这里可以知道 其创建了engine对象和host对象
		tomcat.getHost().setAutoDeploy(false);
		configureEngine(tomcat.getEngine());
		for (Connector additionalConnector : this.additionalTomcatConnectors) {
			tomcat.getService().addConnector(additionalConnector);
		}
		//这里创建了Servlet容器
		prepareContext(tomcat.getHost(), initializers);
		return getTomcatWebServer(tomcat);
	}
	//创建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);
	}
	//构造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 {
	//创建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) {
		//创建了ServletContainerInitializer的实现类
		TomcatStarter starter = new TomcatStarter(initializers);
		...
		//这里直接将其放入到了容器中
		context.addServletContainerInitializer(starter, NO_CLASSES);
		...
	}
}

public class StandardContext extends ContainerBase implements Context, NotificationEmitter {
	//内部有一个集合 用于保存所有ServletContainerInitializer的实现类
    private Map<ServletContainerInitializer,Set<Class<?>>> initializers =
        new LinkedHashMap<>();
	//还记得这个方法吗TomcatEmbeddedContext就是通过该方法将TomcatStarter添加进来的
	public void addServletContainerInitializer(
            ServletContainerInitializer sci, Set<Class<?>> classes) {
        initializers.put(sci, classes);
    }
	//Tomcat启动时会执行该方法 这个方法巨长无比 我只把关键的保留了
	protected synchronized void startInternal() throws LifecycleException {
	    //便利集合
		for (Map.Entry<ServletContainerInitializer, Set<Class<?>>> entry :
                initializers.entrySet()) {
                try {
                    //集合中的key就是ServletContainerInitializer的实现类 这里调用了onStartup方法
                    entry.getKey().onStartup(entry.getValue(),
                    		//最后看下getServletContext方法，看看容器的装饰类到底是什么
                            getServletContext());
                } catch (ServletException e) {
                    log.error(sm.getString("standardContext.sciFail"), e);
                    ok = false;
                    break;
                }
        }
   }
   //这里可以知道容器最终把自己封装到了ApplicationContext对象中，
   //最终将ApplicationContext对象暴露给ServletContainerInitializer实现类
   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接口的实现类
	private final ServletContextInitializer[] initializers;
	//构造器 初始化内部的initializers属性
	TomcatStarter(ServletContextInitializer[] initializers) {
		this.initializers = initializers;
	}
	//这个方法里没有任何servlet的添加操作，而是便利了initializers，并执行initializers每一个实例的onStartup方法，将servletContext当入参传入其中
	@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 {
	//最终这个私有方法会被调用，可以看出如果TomcatStarter中的onStartup方法能调用到该方法，上述说的spirng目的就达成了
	private void selfInitialize(ServletContext servletContext) throws ServletException {
		prepareWebApplicationContext(servletContext);
		registerApplicationScope(servletContext);
		WebApplicationContextUtils.registerEnvironmentBeans(getBeanFactory(), servletContext);
		//这里拿到容器中所有实现了ServletContextInitializer接口的bean并依次执行其onStartup方法 入参是servletContext
		for (ServletContextInitializer beans : getServletContextInitializerBeans()) {
			beans.onStartup(servletContext);
		}
	}
	//ServletContextInitializer本身是一个@FunctionalInterface
	//这里将上述的私有方法封装成了一个ServletContextInitializer实例 很感慨既然还能这样干
	private org.springframework.boot.web.servlet.ServletContextInitializer getSelfInitializer() {
		return this::selfInitialize;
	}	
	//还记得这个方法吗，这里通过factory完成了WebServer的创建，也就是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);
		//集合转数组
		return mergedInitializers.toArray(new ServletContextInitializer[0]);
	}
	//最终会将ServletContextInitializer传入TomcatStarter的构造函数，和之前说的完全对应上了
	protected void configureContext(Context context, ServletContextInitializer[] initializers) {
		TomcatStarter starter = new TomcatStarter(initializers);
		...
	}
}

...省略注解
public class DispatcherServletAutoConfiguration {
	...省略注解
	protected static class DispatcherServletConfiguration {
		//这里创建了DispatcherServlet类
		@Bean(name = DEFAULT_DISPATCHER_SERVLET_BEAN_NAME)
		public DispatcherServlet dispatcherServlet(WebMvcProperties webMvcProperties) {
			...省略DispatcherServlet构造内容
			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实现
		register(description, servletContext);
	}
}

public abstract class DynamicRegistrationBean<D extends Registration.Dynamic> extends RegistrationBean {
	protected final void register(String description, ServletContext servletContext) {
		//servlet注册在这里完成 该方法由子类ServletRegistrationBean实现
		//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实现
		configure(registration);
	}
}

public class ServletRegistrationBean<T extends Servlet> extends DynamicRegistrationBean<ServletRegistration.Dynamic> {
	//这里可以看到servletContext.addServlet方法终于被调用了
	@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);
		}
	}
}