Spring WebMVC 源码分析(4)-Tomcat 服务器启动流程

最新推荐文章于 2022-06-07 15:28:39 发布
最新推荐文章于 2022-06-07 15:28:39 发布
阅读量435 收藏 1
点赞数 2
分类专栏： Tomcat 源码分析 Spring 源码分析 文章标签： spring java spring boot tomcat
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45505313/article/details/119699600
版权

文章目录

1. 前言

在 Spring WebFlux源码分析(1)-服务启动流程 中笔者大致分析了 Spring WebFlux 的启动流程，其实这部分可以说是 SprintBoot 的启动主流程，Spring WebMVC 的启动也由此触发。需要注意的是， Spring WebMVC 框架默认集成 Tomcat 作为底层服务器，如果不指定 WebApplicationType， 那 AbstractApplicationContext 的实现类就变成了 AnnotationConfigServletWebServerApplicationContext，该类继承于 ServletWebServerApplicationContext。 Spring WebMVC 框架中的重要逻辑基本都在 ServletWebServerApplicationContext 中，本文的分析将从这个类开始

2. Tomcat 服务器的启动分析

在这里插入图片描述

2.1 Tomcat 服务器的启动

  1. 我们知道 SpringBoot 框架启动过程中最核心的容器刷新方法 AbstractApplicationContext#refresh() 将被调用，而作为其子类的 ServletWebServerApplicationContext#onRefresh() 方法将被回调，可以看到这个方法的核心逻辑是调用 ServletWebServerApplicationContext#createWebServer() 方法去创建底层服务器

    @Override
 protected void onRefresh() {
 	super.onRefresh();
 	try {
 		createWebServer();
 	}
 	catch (Throwable ex) {
 		throw new ApplicationContextException("Unable to start web server", ex);
 	}
 }

  2. ServletWebServerApplicationContext#createWebServer() 方法的实现如下，比较重要的处理是调用 ServletWebServerApplicationContext#getWebServerFactory() 方法确定一个 Servlet 服务器工厂实例，使用 Tomcat 的话就会取到一个 TomcatServletWebServerFactory 实例，随后使用这个工厂去获取服务器实例，此处需要注意 ServletWebServerApplicationContext#getSelfInitializer() 方法的返回值将作为参数

    private void createWebServer() {
 	WebServer webServer = this.webServer;
 	ServletContext servletContext = getServletContext();
 	if (webServer == null && servletContext == null) {
 		ServletWebServerFactory factory = getWebServerFactory();
 		this.webServer = factory.getWebServer(getSelfInitializer());
 	}
 	else if (servletContext != null) {
 		try {
 			getSelfInitializer().onStartup(servletContext);
 		}
 		catch (ServletException ex) {
 			throw new ApplicationContextException("Cannot initialize servlet context", ex);
 		}
 	}
 	initPropertySources();
 }

  3. ServletWebServerApplicationContext#getSelfInitializer() 方法非常简单，就是将私有方法ServletWebServerApplicationContext#selfInitialize() 作为函数式接口 ServletContextInitializer 的实现返回，此处是将上层的 Servlet/Filter 注入到 Tomcat 中的关键

    private org.springframework.boot.web.servlet.ServletContextInitializer getSelfInitializer() {
 	return this::selfInitialize;
 }

  4. TomcatServletWebServerFactory#getWebServer() 方法将上层的 ServletContextInitializer 初始化对象作为入参，开始创建 Tomcat 服务器对象实例及其重要组件，关键步骤如下，不了解 Tomcat 组件的读者可参考 Tomcat源码分析(1)-结构组成与核心组件

    1. 新建 Tomcat 内部的 Tomcat 实例
    2. 新建 Tomcat 的 Connector 组件，其内部包含的组件都将被创建
    3. tomcat.getService().addConnector() 将先创建 StandardServer 对象，随后创建 StandardService 对象
    4. 调用 TomcatServletWebServerFactory#customizeConnector() 方法将外部对 Connector 组件的定制化配置载入
    5. tomcat.getHost().setAutoDeploy() 首先创建顶级容器对象 StandardEngine，之后将创建代表一个站点的 StandardHost 对象
    6. 调用 TomcatServletWebServerFactory#prepareContext() 方法创建代表一个 web 应用的 TomcatEmbeddedContext 对象，并使用上层的 ServletContextInitializer 对其进行配置
    7. 调用 TomcatServletWebServerFactory#getTomcatWebServer() 方法获取一个面向上层的 WebServer 对象，并启动 Tomcat 服务器
    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 = new Connector(this.protocol);
 	connector.setThrowOnFailure(true);
 	tomcat.getService().addConnector(connector);
 	customizeConnector(connector);
 	tomcat.setConnector(connector);
 	tomcat.getHost().setAutoDeploy(false);
 	configureEngine(tomcat.getEngine());
 	for (Connector additionalConnector : this.additionalTomcatConnectors) {
 		tomcat.getService().addConnector(additionalConnector);
 	}
 	prepareContext(tomcat.getHost(), initializers);
 	return getTomcatWebServer(tomcat);
 }

  5. Tomcat#getService() 方法的内部逻辑是首先尝试获取 Tomcat 的 Server 实例，没有则创建新的 StandardServer 并为其创建 StandardService 组件

     public Service getService() {
     return getServer().findServices()[0];
 }

 public Server getServer() {

     if (server != null) {
         return server;
     }

     System.setProperty("catalina.useNaming", "false");

     server = new StandardServer();

     initBaseDir();

     // Set configuration source
     ConfigFileLoader.setSource(new CatalinaBaseConfigurationSource(new File(basedir), null));

     server.setPort( -1 );

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

  6. Tomcat#getHost() 方法主要负责在服务启动时创建 Tomcat 的重要容器，其内部逻辑与步骤5类似，首先创建顶级顶级容器对象 StandardEngine，之后将创建代表一个站点的 StandardHost 对象

    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 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;
 }

  7. TomcatServletWebServerFactory#prepareContext() 将创建 Tomcat 的 Context 容器并对其进行配置，本文关注的是 TomcatServletWebServerFactory#configureContext() 方法配置 Context 容器的逻辑

    protected void prepareContext(Host host, ServletContextInitializer[] initializers) {
 	File documentRoot = getValidDocumentRoot();
 	TomcatEmbeddedContext context = new TomcatEmbeddedContext();
 	if (documentRoot != null) {
 		context.setResources(new LoaderHidingResourceRoot(context));
 	}
 	context.setName(getContextPath());
 	context.setDisplayName(getDisplayName());
 	context.setPath(getContextPath());
 	File docBase = (documentRoot != null) ? documentRoot : createTempDir("tomcat-docbase");
 	context.setDocBase(docBase.getAbsolutePath());
 	context.addLifecycleListener(new FixContextListener());
 	context.setParentClassLoader((this.resourceLoader != null) ? this.resourceLoader.getClassLoader()
 			: ClassUtils.getDefaultClassLoader());
 	resetDefaultLocaleMapping(context);
 	addLocaleMappings(context);
 	context.setUseRelativeRedirects(false);
 	try {
 		context.setCreateUploadTargets(true);
 	}
 	catch (NoSuchMethodError ex) {
 		// Tomcat is < 8.5.39. Continue.
 	}
 	configureTldSkipPatterns(context);
 	WebappLoader loader = new WebappLoader(context.getParentClassLoader());
 	loader.setLoaderClass(TomcatEmbeddedWebappClassLoader.class.getName());
 	loader.setDelegate(true);
 	context.setLoader(loader);
 	if (isRegisterDefaultServlet()) {
 		addDefaultServlet(context);
 	}
 	if (shouldRegisterJspServlet()) {
 		addJspServlet(context);
 		addJasperInitializer(context);
 	}
 	context.addLifecycleListener(new StaticResourceConfigurer(context));
 	ServletContextInitializer[] initializersToUse = mergeInitializers(initializers);
 	host.addChild(context);
 	configureContext(context, initializersToUse);
 	postProcessContext(context);
 }

  8. TomcatServletWebServerFactory#configureContext() 方法的重要逻辑如下：

    1. 将上层传入的 ServletContextInitializer 列表封装到容器初始化类 TomcatStarter 中，通过 context.addServletContainerInitializer() 添加到 Context 容器内部
    2. 借助 TomcatContextCustomizer 将外部对 Context 容器的定制化配置载入
    protected void configureContext(Context context, ServletContextInitializer[] initializers) {
 	TomcatStarter starter = new TomcatStarter(initializers);
 	if (context instanceof TomcatEmbeddedContext) {
 		TomcatEmbeddedContext embeddedContext = (TomcatEmbeddedContext) context;
 		embeddedContext.setStarter(starter);
 		embeddedContext.setFailCtxIfServletStartFails(true);
 	}
 	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()) {
 		org.apache.tomcat.util.descriptor.web.ErrorPage tomcatErrorPage = new org.apache.tomcat.util.descriptor.web.ErrorPage();
 		tomcatErrorPage.setLocation(errorPage.getPath());
 		tomcatErrorPage.setErrorCode(errorPage.getStatusCode());
 		tomcatErrorPage.setExceptionType(errorPage.getExceptionName());
 		context.addErrorPage(tomcatErrorPage);
 	}
 	for (MimeMappings.Mapping mapping : getMimeMappings()) {
 		context.addMimeMapping(mapping.getExtension(), mapping.getMimeType());
 	}
 	configureSession(context);
 	new DisableReferenceClearingContextCustomizer().customize(context);
 	for (TomcatContextCustomizer customizer : this.tomcatContextCustomizers) {
 		customizer.customize(context);
 	}
 }

  9. TomcatServletWebServerFactory#getTomcatWebServer() 方法将创建一个面向上层的 TomcatWebServer 对象，并在这个类的构造方法中调用 TomcatWebServer#initialize() 方法，最终调用 Tomcat#satrt() 方法启动 Tomcat 服务器

    protected TomcatWebServer getTomcatWebServer(Tomcat tomcat) {
 	return new TomcatWebServer(tomcat, getPort() >= 0);
 }

public TomcatWebServer(Tomcat tomcat, boolean autoStart) {
 	Assert.notNull(tomcat, "Tomcat Server must not be null");
 	this.tomcat = tomcat;
 	this.autoStart = autoStart;
 	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();
 				}
 			});

 			// Start the server to trigger initialization listeners
 			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
 			}

 			// Unlike Jetty, all Tomcat threads are daemon threads. We create a
 			// blocking non-daemon to stop immediate shutdown
 			startDaemonAwaitThread();
 		}
 		catch (Exception ex) {
 			stopSilently();
 			destroySilently();
 			throw new WebServerException("Unable to start embedded Tomcat", ex);
 		}
 	}
 }

  10. Tomcat#satrt() 方法其实就是使用 StandardServer 对象开始整个服务器的启动流程，这部分不再赘述，有兴趣的读者可以参考 Tomcat源码分析(3)-容器 Container 的启动，这个过程将一直调用到 Context 容器的启动方法，也就是 StandardContext#startInternal()，到这一步开始进入下一节分析

     public void start() throws LifecycleException {
    getServer();
    server.start();
}

2.2 Filter 过滤器的注入

  1. StandardContext#startInternal() 这个方法比较长，本文主要关注上层组件的注入流程。在上一节步骤8中笔者提到了上层容器初始化类 TomcatStarter 对象已经添加到 Context 容器内部，此处则主要关注其方法回调的流程

    1. 首先调用 StandardContext#getServletContext() 获取 ServletContext 对象，此处会创建一个 ApplicationContext 对象，并将其包装类 ApplicationContextFacade 对象作为返回值返回
    2. 在启动过程中，会遍历 Context 容器内部初始化器列表并回调ServletContainerInitializers接口方法，则此处将回调到 TomcatStarter#onStartup() 方法
    protected synchronized void startInternal() throws LifecycleException {

         ......

         // Call ServletContainerInitializers
         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;
             }
         }

         ......
 }

  public ServletContext getServletContext() {
     if (context == null) {
         context = new ApplicationContext(this);
         if (altDDName != null)
             context.setAttribute(Globals.ALT_DD_ATTR,altDDName);
     }
     return context.getFacade();
 }

  2. TomcatStarter#onStartup()逻辑非常简单，同样是回调内部的初始化器ServletContextInitializer接口方法，读者如没有印象，可以回到上节步骤3，则可以知道此处将回调到 Spring 上层的 ServletWebServerApplicationContext#selfInitialize() 方法

    public void onStartup(Set<Class<?>> 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());
 		}
 	}
 }

  3. ServletWebServerApplicationContext#selfInitialize() 方法的实现并不复杂，关键是调用 ServletWebServerApplicationContext#getServletContextInitializerBeans() 方法新建一个 ServletContextInitializerBeans对象，在该对象的构造方法中获取 Spring 容器内实现了 ServletContextInitializer 接口的类实例并保存在内部，最后遍历这个新对象并逐一回调其保存的实例的接口方法。 ServletContextInitializer 接口的继承结构如下：
    在这里插入图片描述

    private void selfInitialize(ServletContext servletContext) throws ServletException {
 	prepareWebApplicationContext(servletContext);
 	registerApplicationScope(servletContext);
 	WebApplicationContextUtils.registerEnvironmentBeans(getBeanFactory(), servletContext);
 	for (ServletContextInitializer beans : getServletContextInitializerBeans()) {
 		beans.onStartup(servletContext);
 	}
 }

  4. 本文以 Filter 过滤器 为例分析上层组件注入 Tomcat 容器的过程，则接上一步骤可以知道 FilterRegistrationBean#onStartup() 方法将被触发。这个方法实际由其父类RegistrationBean#onStartup() 实现，核心的逻辑是调用子类实现的 DynamicRegistrationBean#register() 方法

    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);
 }

  5. DynamicRegistrationBean#register() 方法的重要逻辑分为两步：

    1. 调用子类实现的 addRegistration() 方法，返回一个注册器对象，此处将调用到 AbstractFilterRegistrationBean#addRegistration() 方法
    2. 通过这个注册器对象对 Tomcat 服务器做进一步配置，将调用到子类实现 AbstractFilterRegistrationBean#configure() 方法
    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);
 }

  6. AbstractFilterRegistrationBean#addRegistration() 方法比较简单，核心就是调用本节步骤1创建的 ServletContext 对象方法将上层封装在FilterRegistrationBean中的过滤器添加到 Tomcat 内部，此处最终将触发 ApplicationContext#addFilter() 方法

    protected Dynamic addRegistration(String description, ServletContext servletContext) {
 	Filter filter = getFilter();
 	return servletContext.addFilter(getOrDeduceName(filter), filter);
 }

  7. ApplicationContext#addFilter() 方法核心逻辑如下：

    1. 首先将上层的过滤器 Filter 封装为 FilterDef，并将其添加到 Tomcat 的 Context 容器内部列表中
    2. 返回一个封装了 Context 容器的 ApplicationFilterRegistration 对象
    private FilterRegistration.Dynamic addFilter(String filterName,
         String filterClass, Filter filter) throws IllegalStateException {

     if (filterName == null || filterName.equals("")) {
         throw new IllegalArgumentException(sm.getString(
                 "applicationContext.invalidFilterName", filterName));
     }

     if (!context.getState().equals(LifecycleState.STARTING_PREP)) {
         //TODO Spec breaking enhancement to ignore this restriction
         throw new IllegalStateException(
                 sm.getString("applicationContext.addFilter.ise",
                         getContextPath()));
     }

     FilterDef filterDef = context.findFilterDef(filterName);

     // Assume a 'complete' FilterRegistration is one that has a class and
     // a name
     if (filterDef == null) {
         filterDef = new FilterDef();
         filterDef.setFilterName(filterName);
         context.addFilterDef(filterDef);
     } else {
         if (filterDef.getFilterName() != null &&
                 filterDef.getFilterClass() != null) {
             return null;
         }
     }

     if (filter == null) {
         filterDef.setFilterClass(filterClass);
     } else {
         filterDef.setFilterClass(filter.getClass().getName());
         filterDef.setFilter(filter);
     }

     return new ApplicationFilterRegistration(filterDef, context);
 }

  8. 回到本节步骤5第二步，AbstractFilterRegistrationBean#configure() 方法会将 Filter 过滤器 和它应该拦截的 URL 通过新建的注册器对象 ApplicationFilterRegistration#addMappingForUrlPatterns() 方法添加到 Tomcat 的 Context 容器中

    protected void configure(FilterRegistration.Dynamic registration) {
 	super.configure(registration);
 	EnumSet<DispatcherType> dispatcherTypes = this.dispatcherTypes;
 	if (dispatcherTypes == null) {
 		dispatcherTypes = EnumSet.of(DispatcherType.REQUEST);
 	}
 	Set<String> servletNames = new LinkedHashSet<>();
 	for (ServletRegistrationBean<?> servletRegistrationBean : this.servletRegistrationBeans) {
 		servletNames.add(servletRegistrationBean.getServletName());
 	}
 	servletNames.addAll(this.servletNames);
 	if (servletNames.isEmpty() && this.urlPatterns.isEmpty()) {
 		registration.addMappingForUrlPatterns(dispatcherTypes, this.matchAfter, DEFAULT_URL_MAPPINGS);
 	}
 	else {
 		if (!servletNames.isEmpty()) {
 			registration.addMappingForServletNames(dispatcherTypes, this.matchAfter,
 					StringUtils.toStringArray(servletNames));
 		}
 		if (!this.urlPatterns.isEmpty()) {
 			registration.addMappingForUrlPatterns(dispatcherTypes, this.matchAfter,
 					StringUtils.toStringArray(this.urlPatterns));
 		}
 	}
 }

  9. ApplicationFilterRegistration#addMappingForUrlPatterns() 方法如下，可以看到此处新建了一个 FilterMap 对象，并随后将其添加到了 Context 容器中。在网络请求到来时，Tomcat 将会把 Servlet 和对应的 Filter 封装到一个 ApplicationFilterChain 执行链对象中，先执行过滤器逻辑再执行 Servlet 逻辑，读者不清楚可参考 Tomcat源码分析(4)-网络请求处理，至此 Spring MVC 框架 中 Tomcat 服务器的整合分析告一段落

     public void addMappingForUrlPatterns(
         EnumSet<DispatcherType> dispatcherTypes, boolean isMatchAfter,
         String... urlPatterns) {

     FilterMap filterMap = new FilterMap();

     filterMap.setFilterName(filterDef.getFilterName());

     if (dispatcherTypes != null) {
         for (DispatcherType dispatcherType : dispatcherTypes) {
             filterMap.setDispatcher(dispatcherType.name());
         }
     }

     if (urlPatterns != null) {
         // % decoded (if necessary) using UTF-8
         for (String urlPattern : urlPatterns) {
             filterMap.addURLPattern(urlPattern);
         }

         if (isMatchAfter) {
             context.addFilterMap(filterMap);
         } else {
             context.addFilterMapBefore(filterMap);
         }
     }
     // else error?

 }
谈谈1974
关注
专栏目录
【MVC】SpringMVC源码分析之启动流程
qq_43418737的博客
03-17 1112
Spring MVC源码分析之启动流程
精尽Spring Boot源码分析 - 内嵌Tomcat容器的实现
Fightevery的博客
07-02 211
概述 我们知道 Spring Boot 能够创建独立的 Spring 应用，内部嵌入 Tomcat 容器（Jetty、Undertow），让我们的jar无需放入 Servlet 容器就能直接运行。那么对于 Spring Boot 内部嵌入 Tomcat 容器的实现你是否深入的学习过？或许你可以通过这篇文章了解到相关内容。 在上一篇《SpringApplication 启动类的启动过程》文章分析了SpringApplication#run(String... args)启动 Spring 应用...
基于SpringMVC+Tomcat搭建的WEB工程
03-10
编程环境为IDEA，jdk版本1.8；使用springmvc+tomcat来实现一个网页，算是web开发的基础操作，对于初学者应该有帮助，代码的作用我都注释了。后期使用起来方便拓展。
java开发必看|Spring基础知识汇总
java面试笔试
11-17 451
Spring框架是由于软件开发的复杂性而创建的。Spring使用的是基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅仅限于服务器端的开发。从简单性、可测试性和松耦合性的角度而言，绝大部分Java应用都可以从Spring中受益。Spring优点：低侵入式设计，代码的污染极低；独立于各种应用服务器，基于Spring框架的应用，可以真正实现Write Once，Ru
Spring源码解析(17)之refresh(5)-BeanFactoryPostProcessor执行流程源码分析
jokeMqc的博客
02-22 560
一、BeanFactoryPostProcessor与BeanDefinitionRegistryPostProcessor的区别 这里我们把BeanDefinitionRegistryPostProcessor简称为：BDRPP,BeanFactoryPostProcessor简称为：BPP，首先BDRPP继承了BPP，所以它不仅有BPP的方法：postProcessBeanFactory并且有自己的方法：postProcessBeanDefinitionRegistry，那他们的区别主...
Spring搭建Web应用（MVC）起步（Tomcat环境）
anhuidelinger的专栏
11-16 2714
Spring搭建Web应用（MVC）起步（Tomcat环境）   转载▼ 首先，建立WEB应用的目录，必须的。       在tomcat的webapp目录下，创建目录“spring”，目录结构如下：              spring       ----WEB-INF           ----classes           ----lib
玩转 Spring Boot 原理篇（启动机制源码剖析）
一猿小讲
03-31 276
0.0.0. 历史文章整理玩转 Spring Boot 入门篇玩转 Spring Boot 集成篇（MySQL、Druid、HikariCP）玩转 Spring Boot 集成篇（MyBatis、JPA、事务支持）玩转 Spring Boot 集成篇（Redis）玩转 Spring Boot 集成篇（Actuator、Spring Boot Admin）玩转 Sprin...
Spring Boot源码（spring-boot-2.6.2.zip）
01-07
4. `org.springframework.boot.context.embedded.*`: 内嵌Web服务器的接口和实现。 5. `org.springframework.boot.context.properties.*`: 属性绑定和配置源的处理。 通过阅读这些核心组件的源码，我们可以深入理解...
官方源码 spring-framework-5.2.15.RELEASE.zip
05-18
8. **源码分析** 分析源码有助于我们理解Spring的内部工作原理。例如，通过查看ApplicationContext的实现，我们可以看到如何加载和管理bean；通过研究DispatcherServlet，可以了解Spring MVC的请求处理流程；通过...
一个改进版的spring-mvc-showcase
03-28
其次，`start_tomcat.bat`是一个批处理脚本，通常用于启动Apache Tomcat服务器。Tomcat是一个流行的Java应用服务器，尤其适合部署Servlet和JSP应用，如Spring MVC项目。这个脚本可能包含了设置环境变量、定位到...
Spring Mvc与Tomcat的整理
qq_29860591的博客
11-04 2115
Spring Mvc与Tomcat的整理 在spring的源码基础上，新建一个模块springmvc-source-test,勾选gradle模块，选中java和web。 在gradle的配置文件中，引入下面2个依赖 // https://mvnrepository.com/artifact/javax.servlet/javax.servlet-api compileOnl...
Web容器、Tomcat、Spring、SpringMvc
weixin_39132087的博客
12-29 427
Tomcat整体结构 ​​​​​​​ Tomcat整体启动流程 catalina.sh中可以看到：set MAINCLASS=org.apache.catalina.startup.Bootstrap Bootstrap通过反射实例化Catalina，并调用其load()，start()方法 Init Start 添加StandardHost时，会为其添加一个HostConfig的监...
SpringMVC配置以及Tomcat进行调试
Scyth1的博客
06-07 1214
1.新建项目2.选择创建maven3.设置项目名称和包名4.选择Maven home 5.找到maven解压包下的conf里面的setting.xml6.删除冗余部分 7.导入jar包 等待加载完毕8.打开web.xml 替换内容 9.在web.xml配置文件中核心控制器DispatcherServlet web.xml中的spring.xml报红不用担心，下面步骤解决报红问题 10.配置springmvc.xml（1）创建java和resource目录在main目录下创建Java和reso
内置tomcat整合SpringMVC
qinshuluye2013的专栏
12-11 2564
spring MVC是一个基于MVC模式的表现层框架，在spring2.5以后增加了注解功能。使得开发变得更加高效、快捷。由于spring MVC是spring框架的一个模块，springmvc和spring无需通过中间整合层进行整合，可以达到无缝整合。 springMVC的特点有： 　　　　1、基于的是servlet/jsp模式 2、控制器不再需要继承其它类，只需要用@Controller注解 　　　 3、应用控制器方法参数，由前端控制器负责封装，方法签名...
SpringMVC（一）第一个SpringMVC程序
你佳哥
12-21 674
基于：【狂神说Java】SpringMVC最新教程IDEA版通俗易懂 目录1 MVC 1 MVC model（模型）：数据模型，提供要展示的数据，现在一般包括数据Dao和行为Service； view（视图）：负责进行模型的展示，一般就是用户交互界面； Controller（控制器）：调度model和view，接受请求，委托给模型处理，返回数据，由视图展示； ...
IntelliJ IDEA 配置tomcat 启动项目
weixin_30917213的博客
03-28 1613
1.打开file中setting中搜索Application Servers，如下图 2.添加服务器类型，例如tomcat，如下图，添加完成之后可以选定tomcat的目录，tomcat Home配置tomcat的自定目录。 3.搜索tomcat，如下图，选定选定之后将后面的选择框（小正方形)选中. 4.创建一个java web项目，测试tomcat的是否配置成功. 5.打开...
基于Spring MVC和Tomcat服务器的JavaWeb项目----入门篇
热门推荐
浅语
09-05 2万+
1 软件工具准备（1） JDK: jdk-8u92-windows-i586.exe (jdk1.8.0_92) （2） Eclipse：eclipse-jee-luna-SR2-win32.zip （3） Tomcat: apache-tomcat-7.0.70-windows-x86.zip （4） Spring-framework: spring-framework-4.3.2.RELE
SpringMVC和Tomcat开发web
HOMERUNIT的博客
04-15 1938
一、下载与安装SpringMVC和Tomcat 1、项目构建 1）JDK官网下载地址： http://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html 2）Eclipse官网下载地址： http://www.eclipse.org/downloads/eclipse-packag...
Tomcat和SpringMVC的关系
qq_40277163的博客
05-12 3352
Tomcat是一个web服务器&&应用流程 1） 用户通过浏览器进行了一个操作，比如输入网址并回车，或者是点击链接，接着浏览 器获取了这个事件。 2） 浏览器向服务端发出TCP连接请求。 3） 服务程序接受浏览器的连接请求，并经过TCP三次握手建立连接。 4） 浏览器将请求数据打包成一个HTTP协议格式的数据包。 5） 浏览器将该数据包推入网络，数据包经过网络传输，最终达到端服务程序。 6） 服务端程序拿到这个数据包后，同样以HTTP协议格式解包，获取到客户端的意图。 7） 得知客户端意图
深入解析：Spring Boot中Tomcat的启动过程
通过这个过程，Spring Boot成功地启动了内置的Tomcat服务器，使得Web应用程序能够在不依赖外部容器的情况下运行。这个设计极大地简化了开发和部署流程，让开发者可以更加专注于业务逻辑。同时，深入理解这一过程有助...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值