如何在SpringBoot中内嵌Tomcat并启动

private void createEmbeddedServletContainer() {
 EmbeddedServletContainer localContainer = this.embeddedServletContainer;
 ServletContext localServletContext = getServletContext();
 if (localContainer == null && localServletContext == null) {
  EmbeddedServletContainerFactory containerFactory = getEmbeddedServletContainerFactory();
  this.embeddedServletContainer = containerFactory
   .getEmbeddedServletContainer(getSelfInitializer());
 }
 else if (localServletContext != null) {
  try {
  getSelfInitializer().onStartup(localServletContext);
  }
  catch (ServletException ex) {
  throw new ApplicationContextException("Cannot initialize servlet context",
   ex);
  }
 }
 initPropertySources();
 }

 private org.springframework.boot.web.servlet.ServletContextInitializer getSelfInitializer() {
 return new ServletContextInitializer() {
  @Override
  public void onStartup(ServletContext servletContext) throws ServletException {
  selfInitialize(servletContext);
  }
 };
 }

 Tomcat tomcat = new Tomcat();

 Connector connector = new Connector(this.protocol);

protected void initBaseDir() {
 String catalinaHome = System.getProperty(Globals.CATALINA_HOME_PROP);
 if (basedir == null) {
  basedir = System.getProperty(Globals.CATALINA_BASE_PROP);
 }
 if (basedir == null) {
  basedir = catalinaHome;
 }
 if (basedir == null) {
  // Create a temp dir.
  basedir = System.getProperty("user.dir") +
  "/tomcat." + port;
 }
 File baseFile = new File(basedir);
 baseFile.mkdirs();
 try {
  baseFile = baseFile.getCanonicalFile();
 } catch (IOException e) {
  baseFile = baseFile.getAbsoluteFile();
 }
 server.setCatalinaBase(baseFile);
 System.setProperty(Globals.CATALINA_BASE_PROP, baseFile.getPath());
 basedir = baseFile.getPath();
 if (catalinaHome == null) {
  server.setCatalinaHome(baseFile);
 } else {
  File homeFile = new File(catalinaHome);
  homeFile.mkdirs();
  try {
  homeFile = homeFile.getCanonicalFile();
  } catch (IOException e) {
  homeFile = homeFile.getAbsoluteFile();
  }
  server.setCatalinaHome(homeFile);
 }
 System.setProperty(Globals.CATALINA_HOME_PROP,
  server.getCatalinaHome().getPath());
 }

 service = new StandardService();
 service.setName("Tomcat");
 server.addService( service )

 private void addDefaultServlet(Context context) {
 Wrapper defaultServlet = context.createWrapper();
 defaultServlet.setName("default");
 defaultServlet.setServletClass("org.apache.catalina.servlets.DefaultServlet");
 defaultServlet.addInitParameter("debug", "0");
 defaultServlet.addInitParameter("listings", "false");
 defaultServlet.setLoadOnStartup(1);
 // Otherwise the default location of a Spring DispatcherServlet cannot be set
 defaultServlet.setOverridable(true);
 context.addChild(defaultServlet);
 addServletMapping(context, "/", "default");
 }

 protected final ServletContextInitializer[] mergeInitializers(
  ServletContextInitializer... initializers) {
 List mergedInitializers = new ArrayList();
 mergedInitializers.addAll(Arrays.asList(initializers));
 mergedInitializers.addAll(this.initializers);
 return mergedInitializers
  .toArray(new ServletContextInitializer[mergedInitializers.size()]);
 }

 TomcatStarter starter = new TomcatStarter(initializers);
 if (context instanceof TomcatEmbeddedContext) {
  // Should be true
  ((TomcatEmbeddedContext) context).setStarter(starter);
 }
 context.addServletContainerInitializer(starter, NO_CLASSES);
 for (LifecycleListener lifecycleListener : this.contextLifecycleListeners) {
  context.addLifecycleListener(lifecycleListener);
 }
 for (Valve valve : this.contextValves) {
  context.getPipeline().addValve(valve);
 }
 for (ErrorPage errorPage : getErrorPages()) {
  new TomcatErrorPage(errorPage).addToContext(context);
 }
 for (MimeMappings.Mapping mapping : getMimeMappings()) {
  context.addMimeMapping(mapping.getExtension(), mapping.getMimeType());
 }

protected TomcatEmbeddedServletContainer getTomcatEmbeddedServletContainer(
  Tomcat tomcat) {
 return new TomcatEmbeddedServletContainer(tomcat, getPort() >= 0);
 }

 public TomcatEmbeddedServletContainer(Tomcat tomcat, boolean autoStart) {
 Assert.notNull(tomcat, "Tomcat Server must not be null");
 this.tomcat = tomcat;
 this.autoStart = autoStart;
 initialize();
 }

 private void addInstanceIdToEngineName() {
 int instanceId = containerCounter.incrementAndGet();
 if (instanceId > 0) {
  Engine engine = this.tomcat.getEngine();
  engine.setName(engine.getName() + "-" + instanceId);
 }
 }

 @Override
 public void onStartup(Set> classes, ServletContext servletContext)
  throws ServletException {
 try {
  for (ServletContextInitializer initializer : this.initializers) {
  initializer.onStartup(servletContext);
  }
 }
 catch (Exception ex) {
  this.startUpException = ex;
  // Prevent Tomcat from logging and re-throwing when we know we can
  // deal with it in the main thread, but log for information here.
  if (logger.isErrorEnabled()) {
  logger.error("Error starting Tomcat context. Exception: "
   + ex.getClass().getName() + ". Message: " + ex.getMessage());
  }
 }
 }

 private Context findContext() {
 for (Container child : this.tomcat.getHost().findChildren()) {
  if (child instanceof Context) {
  return (Context) child;
  }
 }
 throw new IllegalStateException("The host does not contain a Context");
 }

 try {
   ContextBindings.bindClassLoader(context, getNamingToken(context),
    getClass().getClassLoader());
  }
  catch (NamingException ex) {
   // Naming is not enabled. Continue
  }

 private void startDaemonAwaitThread() {
 Thread awaitThread = new Thread("container-" + (containerCounter.get())) {
  @Override
  public void run() {
  TomcatEmbeddedServletContainer.this.tomcat.getServer().await();
  }
 };
 awaitThread.setContextClassLoader(getClass().getClassLoader());
 awaitThread.setDaemon(false);
 awaitThread.start();
 }

 try {
  awaitThread = Thread.currentThread();
  while(!stopAwait) {
   try {
   Thread.sleep( 10000 );
   } catch( InterruptedException ex ) {
   // continue and check the flag
   }
  }
  } finally {
  awaitThread = null;
  }
  return;

 /**
 * {@inheritDoc}
 * 
Replace {@code Servlet}-related property sources.
 */
 @Override
 protected void initPropertySources() {
 ConfigurableEnvironment env = getEnvironment();
 if (env instanceof ConfigurableWebEnvironment) {
  ((ConfigurableWebEnvironment) env).initPropertySources(this.servletContext, null);
 }
 }