一、引言
传统的SSM框架开发需要多种配置文件，application.xml、springmvc.xml、web.xml等等，然后对写好的程序进行编译、打包，丢到tomcat的webapp下部署、启动。但是经过后续框架的发展，基本可以做到零配置文件，也不需要单独安装tomcat进行部署。实现的原理就是Spring提供的java config，以及内置的tomcat，当然目前已经存在了一种把他们整合在一起的框架了，就是Springboot，如果我们不用Springboot，该怎么做呢？
二、 示例
1、添加jar包
compile("org.apache.tomcat.embed:tomcat-embed-core:9.0.12")
compile("org.apache.tomcat.embed:tomcat-embed-jasper:9.0.12")
//spring相关的就省略了，自行添加
2、编写mvc配置类
@Configuration @ComponentScan("com.luban.mybatis") public class AppConfig extends WebMvcConfigurationSupport { }
3、添加自定义初始化类
public class MyWebApplicationInitialier implements WebApplicationInitializer { @Override public void onStartup(ServletContext servletContext) throws ServletException { //用java注解的方式，去初始化spring上下文环境 AnnotationConfigWebApplicationContext ac = new AnnotationConfigWebApplicationContext(); ac.register(AppConfig.class); System.out.println("init context"); DispatcherServlet servlet = new DispatcherServlet(ac); ServletRegistration.Dynamic registration = servletContext.addServlet("app", servlet); registration.setLoadOnStartup(1); registration.addMapping("/app/*"); } }
4、main方法
public class AppTest { public static void main(String[] args) throws LifecycleException, ClassNotFoundException, IllegalAccessException, InstantiationException { Tomcat tomcat = new Tomcat(); tomcat.setPort(8081); tomcat.addWebapp("/", "C:\\workspace\\software\\apache-tomcat-9.0.55"); tomcat.start(); //强制Tomcat server等待，避免main线程执行结束后关闭 tomcat.getServer().await(); } }
5、控制层
@RestController @RequestMapping("/test") public class TestController { @RequestMapping("/get") public String testGet() { return "ok"; } }
三、源码解析
1、tomcat启动SPI机制
tomcat启动时，在初始化StandardContext类时，会加载resources\META-INF\services\javax.servlet.ServletContainerInitializer文件中配置的实现类，并调用其onStartup方法
org.springframework.web.SpringServletContainerInitializer
初始化StandardContext，调用startInternal方法
protected synchronized void startInternal() throws LifecycleException { ··· try { ··· // 生命周期事件 fireLifecycleEvent(Lifecycle.CONFIGURE_START_EVENT, null); ··· // 调用 ServletContainerInitializers 实现类的onStartup方法，并将initializers的value值set集合和servlet上下文传进去 for (Map.Entry<ServletContainerInitializer, Set<Class<?>>> entry : initializers.entrySet()) { try { entry.getKey().onStartup(entry.getValue(), getServletContext()); } catch (ServletException e) { log.error(sm.getString("standardContext.sciFail"), e); ok = false; break; } } ··· } finally { ··· } ··· }
1、触发生命周期事件
protected void fireLifecycleEvent(String type, Object data) { LifecycleEvent event = new LifecycleEvent(this, type, data); for (LifecycleListener listener : lifecycleListeners) { listener.lifecycleEvent(event); } } //ContextConfig public void lifecycleEvent(LifecycleEvent event) { ``` // Process the event that has occurred if (event.getType().equals(Lifecycle.CONFIGURE_START_EVENT)) { configureStart(); } ``` } protected synchronized void configureStart() { ``` webConfig(); ``` }
protected void webConfig() { ··· // 找到 ServletContainerInitializer 所有的实现类 // 放到initializerClassMap中，key是实现类，value是一个set集合用于存储@HandlesTypes注解的实现类 if (ok) { processServletContainerInitializers(); } ··· if (!webXml.isMetadataComplete() || typeInitializerMap.size() > 0) { // 从所有jar包中找出所有ServletContainerInitializer实现类上使用了@HandlesTypes注解 // 的value值对应的接口的实现类，放入到initializerClassMap的value值中 if (ok) { processAnnotations( orderedFragments, webXml.isMetadataComplete(), javaClassCache); } } // 把找到的ServletContainerInitializer配置放入StandardContext的属性initializers中 if (ok) { for (Map.Entry<ServletContainerInitializer, Set<Class<?>>> entry : initializerClassMap.entrySet()) { if (entry.getValue().isEmpty()) { context.addServletContainerInitializer( entry.getKey(), null); } else { context.addServletContainerInitializer( entry.getKey(), entry.getValue()); } } } }
找到所有ServletContainerInitializer的实现类
protected void processServletContainerInitializers() { List<ServletContainerInitializer> detectedScis; try { //找到并加载ServletContainerInitializer的实现类 WebappServiceLoader<ServletContainerInitializer> loader = new WebappServiceLoader<>(context); detectedScis = loader.load(ServletContainerInitializer.class); } catch (IOException e) { log.error(sm.getString( "contextConfig.servletContainerInitializerFail", context.getName()), e); ok = false; return; } for (ServletContainerInitializer sci : detectedScis) { //存放ServletContainerInitializer的实现类，初始化value值 initializerClassMap.put(sci, new HashSet<Class<?>>()); ··· } }
添加到StandardContext的initializers属性中去
//StandardContext public void addServletContainerInitializer( ServletContainerInitializer sci, Set<Class<?>> classes) { initializers.put(sci, classes); }
2、调用ServletContainerInitializer所有实现类的onStartup方法
@HandlesTypes(WebApplicationInitializer.class) public class SpringServletContainerInitializer implements ServletContainerInitializer { @Override public void onStartup(@Nullable Set<Class<?>> webAppInitializerClasses, ServletContext servletContext) throws ServletException { List<WebApplicationInitializer> initializers = new LinkedList<>(); if (webAppInitializerClasses != null) { for (Class<?> waiClass : webAppInitializerClasses) { // Be defensive: Some servlet containers provide us with invalid classes, // no matter what @HandlesTypes says... if (!waiClass.isInterface() && !Modifier.isAbstract(waiClass.getModifiers()) && WebApplicationInitializer.class.isAssignableFrom(waiClass)) { try { initializers.add((WebApplicationInitializer) ReflectionUtils.accessibleConstructor(waiClass).newInstance()); } catch (Throwable ex) { throw new ServletException("Failed to instantiate WebApplicationInitializer class", ex); } } } } if (initializers.isEmpty()) { servletContext.log("No Spring WebApplicationInitializer types detected on classpath"); return; } servletContext.log(initializers.size() + " Spring WebApplicationInitializers detected on classpath"); AnnotationAwareOrderComparator.sort(initializers); for (WebApplicationInitializer initializer : initializers) { //调用HandlesTypes注解的所有实现类的onStartup方法 initializer.onStartup(servletContext); } } }
这里就会调用到我们自定义的MyWebApplicationInitialier实现类的onStartup方法，并且传入了servlet的上下文，具体就不再解析了，都是spring容器的初始化内容，以前也都讲解过了。
四、spring-boot的内嵌tomcat原理
springboot的启动使用的是一个main方法，调用的是SpringApplication.run(GtripApplication.class, args)方法，我们直接来看这个方法。
public static ConfigurableApplicationContext run(Class<?> primarySource, String... args) { return run(new Class<?>[] { primarySource }, args); } public static ConfigurableApplicationContext run(Class<?>[] primarySources, String[] args) { return new SpringApplication(primarySources).run(args); } public ConfigurableApplicationContext run(String... args) { ``` refreshContext(context); ··· return context; } private void refreshContext(ConfigurableApplicationContext context) { if (this.registerShutdownHook) { shutdownHook.registerApplicationContext(context); } refresh(context); } protected void refresh(ApplicationContext applicationContext) { Assert.isInstanceOf(ConfigurableApplicationContext.class, applicationContext); refresh((ConfigurableApplicationContext) applicationContext); } protected void refresh(ConfigurableApplicationContext applicationContext) { applicationContext.refresh(); } //ServletWebServerApplicationContext public final void refresh() throws BeansException, IllegalStateException { try { //调用父类的refresh方法 super.refresh(); } catch (RuntimeException ex) { WebServer webServer = this.webServer; if (webServer != null) { webServer.stop(); } throw ex; } } //AbstractApplicationContext public void refresh() throws BeansException, IllegalStateException { ··· //调用子类的方法 onRefresh(); ··· } //ServletWebServerApplicationContext protected void onRefresh() { super.onRefresh(); try { //创建web容器 createWebServer(); } catch (Throwable ex) { throw new ApplicationContextException("Unable to start web server", ex); } }
父类的refresh方法就不多讲了，之前已经讲过了spring的源码，在onRefresh方法里，子类上下文对这个方法进行了重写，创建了web容器。
private void createWebServer() { WebServer webServer = this.webServer; //如果使用的是jar包启动，获取的一定是null ServletContext servletContext = getServletContext(); if (webServer == null && servletContext == null) { //获取到的是ServletWebServerFactory类型的bean，是一个工厂 ServletWebServerFactory factory = getWebServerFactory(); //创建并启动web容器 this.webServer = factory.getWebServer(getSelfInitializer()); getBeanFactory().registerSingleton("webServerGracefulShutdown", new WebServerGracefulShutdownLifecycle(this.webServer)); getBeanFactory().registerSingleton("webServerStartStop", new WebServerStartStopLifecycle(this, this.webServer)); } else if (servletContext != null) { try { getSelfInitializer().onStartup(servletContext); } catch (ServletException ex) { throw new ApplicationContextException("Cannot initialize servlet context", ex); } } initPropertySources(); }
这里提前放入了一段lambda表达式getSelfInitializer()，后续会执行
private org.springframework.boot.web.servlet.ServletContextInitializer getSelfInitializer() { //返回的是一个lambda表达式 return this::selfInitialize; } private void selfInitialize(ServletContext servletContext) throws ServletException { prepareWebApplicationContext(servletContext); registerApplicationScope(servletContext); WebApplicationContextUtils.registerEnvironmentBeans(getBeanFactory(), servletContext); for (ServletContextInitializer beans : getServletContextInitializerBeans()) { beans.onStartup(servletContext); } }
继续创建webServer
public WebServer getWebServer(ServletContextInitializer... initializers) { if (this.disableMBeanRegistry) { Registry.disableRegistry(); } //创建实例 Tomcat tomcat = new Tomcat(); File baseDir = (this.baseDirectory != null) ? this.baseDirectory : createTempDir("tomcat"); tomcat.setBaseDir(baseDir.getAbsolutePath()); //实例化connector Connector connector = new Connector(this.protocol); connector.setThrowOnFailure(true); tomcat.getService().addConnector(connector); customizeConnector(connector); tomcat.setConnector(connector); tomcat.getHost().setAutoDeploy(false); //Engine configureEngine(tomcat.getEngine()); for (Connector additionalConnector : this.additionalTomcatConnectors) { tomcat.getService().addConnector(additionalConnector); }
//初始化DispatcherServlet的关键代码 prepareContext(tomcat.getHost(), initializers); //启动tomcat return getTomcatWebServer(tomcat); } protected TomcatWebServer getTomcatWebServer(Tomcat tomcat) { return new TomcatWebServer(tomcat, getPort() >= 0, getShutdown()); } public TomcatWebServer(Tomcat tomcat, boolean autoStart, Shutdown shutdown) { Assert.notNull(tomcat, "Tomcat Server must not be null"); this.tomcat = tomcat; this.autoStart = autoStart; this.gracefulShutdown = (shutdown == Shutdown.GRACEFUL) ? new GracefulShutdown(tomcat) : null; initialize(); } private void initialize() throws WebServerException { logger.info("Tomcat initialized with port(s): " + getPortsDescription(false)); synchronized (this.monitor) { try { addInstanceIdToEngineName(); Context context = findContext(); context.addLifecycleListener((event) -> { if (context.equals(event.getSource()) && Lifecycle.START_EVENT.equals(event.getType())) { // Remove service connectors so that protocol binding doesn't // happen when the service is started. removeServiceConnectors(); } }); // 启动tomcat this.tomcat.start(); // We can re-throw failure exception directly in the main thread rethrowDeferredStartupExceptions(); try { ContextBindings.bindClassLoader(context, context.getNamingToken(), getClass().getClassLoader()); } catch (NamingException ex) { // Naming is not enabled. Continue } // 启动了一个守护线程，防止线程停止 startDaemonAwaitThread(); } catch (Exception ex) { stopSilently(); destroySilently(); throw new WebServerException("Unable to start embedded Tomcat", ex); } } }
关键代码prepareContext(tomcat.getHost(), initializers)
protected void prepareContext(Host host, ServletContextInitializer[] initializers) { ``` ServletContextInitializer[] initializersToUse = mergeInitializers(initializers); host.addChild(context); configureContext(context, initializersToUse); ``` } protected void configureContext(Context context, ServletContextInitializer[] initializers) { TomcatStarter starter = new TomcatStarter(initializers); ``` } //实现了ServletContainerInitializer接口，那么创建StandardContext的时候，就会调用他的onStartup方法 class TomcatStarter implements ServletContainerInitializer { private static final Log logger = LogFactory.getLog(TomcatStarter.class); private final ServletContextInitializer[] initializers; private volatile Exception startUpException; TomcatStarter(ServletContextInitializer[] initializers) { this.initializers = initializers; } @Override public void onStartup(Set<Class<?>> classes, ServletContext servletContext) throws ServletException { try { for (ServletContextInitializer initializer : this.initializers) { //执行之前放入的lambda表达式的onStartup方法 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()); } } } Exception getStartUpException() { return this.startUpException; } }
可以看到之前加入的lambda表达式，最终被封装到了TomcatStarter，它实现了ServletContainerInitializer接口，那么最后在创建StandardContext的时候，会调用lambda表达式的onStartup方法。
//RegistrationBean public final void onStartup(ServletContext servletContext) throws ServletException { String description = getDescription(); if (!isEnabled()) { logger.info(StringUtils.capitalize(description) + " was not registered (disabled)"); return; } register(description, servletContext); } //DynamicRegistrationBean protected final void register(String description, ServletContext servletContext) { D registration = addRegistration(description, servletContext); if (registration == null) { logger.info(StringUtils.capitalize(description) + " was not registered (possibly already registered?)"); return; } configure(registration); } //ServletRegistrationBean protected ServletRegistration.Dynamic addRegistration(String description, ServletContext servletContext) { String name = getServletName(); //把DispatcherServlet放入到tomcat上下文 return servletContext.addServlet(name, this.servlet); }
调用tomcat的start方法，然后就是后续的向内引爆，启动一个一个子容器。
Springboot2.3.5版本tomcat配置
最大连接数：在同一时间，tomcat能够接受的最大连接数。对于Java的阻塞式BIO，默认值是maxthreads的值；如果在BIO模式使用定制的Executor执行器，默认值将是执行器中maxthreads的值。对于Java新的NIO模式，maxConnections 默认值是8192。
最大线程数：每一次HTTP请求到达Web服务，tomcat都会创建一个线程来处理该请求，那么最大线程数决定了Web服务容器可以同时处理多少个请求。maxThreads默认200，可以适当增加，但是，增加线程是有成本的，更多的线程，不仅仅会带来更多的线程上下文切换成本，而且意味着带来更多的内存消耗。JVM中默认情况下在创建新线程时会分配大小为1M的线程栈，所以，更多的线程异味着需要更多的内存。这里给出的建议：1核2g内存，线程数建议200；4核8g内存，线程数建议800。
等待连接数：当所有的请求处理线程都在使用时，所能接收的连接请求的队列的最大长度。当队列已满时，任何的连接请求都将被拒绝，默认值100。
最小工作空闲线程数：默认值10
在ServerProperties类中
//最大连接数 private int maxConnections = 8192; //等待连接数 private int acceptCount = 100; //最大线程数 @Deprecated @DeprecatedConfigurationProperty(replacement = "server.tomcat.threads.max") public int getMaxThreads() { return getThreads().getMax(); } //最小工作空闲线程数 @Deprecated @DeprecatedConfigurationProperty(replacement = "server.tomcat.threads.min-spare") public int getMinSpareThreads() { return getThreads().getMinSpare(); } public static class Threads { private int max = 200; private int minSpare = 10; }
最大线程数和最小工作空闲线程数都可以通过相应的配置修改。