传统tomcat启动服务与springboot启动内置tomcat服务的区别(推荐)

spring整合springmvc

•  spring整合springmvc中web.xml配置如下，tomcat在启动过程中会加载web.xml中的内容，contextloaderlistener实现了tomcat里面的servletcontextlistener接口，所以在tomcat容器启动过程通过contextloaderlistener来进行spring容器的初始化操作，并将classpath:spring/applicationcontext-*.xml指定下的spring配置文件加载，该配置文件我只配置了<context:component-scan base-package=“org.com.yp”/>，代表通过扫描org.com.yp包下的类，包含@component @controller@service等注解等类，进行bean注册。
• bean注册是通过abstractxmlapplicationcontext.loadbeandefinitions该类的方法进行bean定义加载的。

spring中加载bean定义是在org.springframework.context.configurableapplicationcontext#refresh方法中的configurablelistablebeanfactory beanfactory = obtainfreshbeanfactory()方法加载bean的，该方法之后会调用org.springframework.context.support.abstractrefreshableapplicationcontext#refreshbeanfactory方法创建bean工厂，并加载的bean定义。

<?xml version="1.0" encoding="utf-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/xmlschema-instance"
         xmlns="http://java.sun.com/xml/ns/javaee"
         xsi:schemalocation="http://java.sun.com/xml/ns/javaee
                             http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" id="webapp_id" version="3.0">
  <display-name>archetype created web application</display-name>
  <listener>
    <listener-class>org.springframework.web.context.contextloaderlistener</listener-class>
  </listener>
  <!-- 加载spring容器 -->
  <context-param>
    <param-name>contextconfiglocation</param-name>
    <param-value>classpath:spring/applicationcontext-*.xml</param-value>
  </context-param>
​
  <servlet>
    <servlet-name>mvc-dispatcher</servlet-name>
    <servlet-class>org.springframework.web.servlet.dispatcherservlet</servlet-class>
    <!-- 配置springmvc需要加载的配置文件-->
    <init-param>
      <param-name>contextconfiglocation</param-name>
      <param-value>classpath:spring/spring-*.xml</param-value>
    </init-param>
  </servlet>
​
  <servlet-mapping>
    <servlet-name>mvc-dispatcher</servlet-name>
    <!-- 默认匹配所有的请求 -->
    <url-pattern>/</url-pattern>
  </servlet-mapping>
</web-app>

当tomcat容器启动后，通过路径访问资源时，第一次会调用org.springframework.web.servlet.httpservletbean#init方法，之后的http请求就不会再方法该方法类；httpservletbean实现了servlet接口的规范，所以经过浏览器的请求经过servlet接口初始化执行init方法时，会再从spring容器中去加载springmvc配置中定义的加载类，spring与springmvc是父子容器的关系，下面是httpservletbean的init方法

public final void init() throws servletexception {
		// set bean properties from init parameters.
		propertyvalues pvs = new servletconfigpropertyvalues(getservletconfig(), this.requiredproperties);
		if (!pvs.isempty()) {
			try {
				beanwrapper bw = propertyaccessorfactory.forbeanpropertyaccess(this);
				resourceloader resourceloader = new servletcontextresourceloader(getservletcontext());
				bw.registercustomeditor(resource.class, new resourceeditor(resourceloader, getenvironment()));
				initbeanwrapper(bw);
				bw.setpropertyvalues(pvs, true);
			}
			catch (beansexception ex) {
				if (logger.iserrorenabled()) {
					logger.error("failed to set bean properties on servlet '" + getservletname() + "'", ex);
				}
				throw ex;
			}
		}

        // 最后会调用org.springframework.context.configurableapplicationcontext#refresh容器的刷新方法，
        // 进行springmvc容器初始化
		initservletbean();
	}
    }

springboot启动容器

•  springboot启动的方式则是先在springboot的org.springframework.boot.springapplication#run(java.lang.string…)方法中就初始化了spring的上下文环境(里面包含bean工厂)，之后通过org.springframework.boot.springapplication#refreshcontext方法调用spring容器中的configurableapplicationcontext#refresh方法初始化bean.
• 在spring与springmvc整合的环境中，bean定义的加载是在org.springframework.context.support.abstractapplicationcontext#obtainfreshbeanfactory方法，而springboot中是在

org.springframework.context.support.abstractapplicationcontext#invokebeanfactorypostprocessors方法，该方法中通过configurationclasspostprocessor类去加载bean定义，该类实现了beandefinitionregistrypostprocessor接口，这个接口允许对bean定义进行加工处理。

// spring中的beandefinitionregistrypostprocessor是beanfactorypostprocessor的子接口，
// beanfactorypostprocessor的作用是在bean的定义信息已经加载但还没有初始化的时候执行方法postprocessbeanfactory(）方法，
// 而beandefinitionregistrypostprocessor是在beanfactorypostprocessor的前面执行，在源码
// org.springframework.context.support.postprocessorregistrationdelegate#invokebeanfactorypostprocessors()方法里面定义了执行顺序
// beanfactorypostprocessor是bean工厂的bean属性处理容器，说通俗一些就是可以管理我们的bean工厂内所有的beandefinition（未实例化）数据，可以随心所欲的修改属性。
public void refresh() throws beansexception, illegalstateexception {
        synchronized (this.startupshutdownmonitor) {
            preparerefresh();
            
            //获取告诉子类初始化bean工厂 将bean加载到缓存中 spring springmvc整合是在这初始化bean的
            configurablelistablebeanfactory beanfactory = obtainfreshbeanfactory();
            
            preparebeanfactory(beanfactory);
​
            try {
                postprocessbeanfactory(beanfactory);
​
                // springboot容器启动加载到这时，初始化了下面几个bean name
                //0 = "org.springframework.context.annotation.internalconfigurationannotationprocessor" =》对应configurationclasspostprocessor类
                //1 = "org.springframework.context.annotation.internalautowiredannotationprocessor" =》 autowiredannotationbeanpostprocessor
                //2 = "org.springframework.context.annotation.internalcommonannotationprocessor" =》 commonannotationbeanpostprocessor
                //3 = "org.springframework.context.event.internaleventlistenerprocessor" =》 eventlistenermethodprocessor
                //4 = "org.springframework.context.event.internaleventlistenerfactory" =》 defaulteventlistenerfactory
                // 调用我们的bean工厂的后置处理器.加载bean定义（不是实例化）,通过configurationclasspostprocessor去加载启动类中的扫描路径
                // 然后将路径下到bean加载进来
                invokebeanfactorypostprocessors(beanfactory);
​
                registerbeanpostprocessors(beanfactory);
​
                initmessagesource();
​
                initapplicationeventmulticaster();
​
                // 这个方法同样也是留个子类实现的springboot也是从这个方法进行启动tomat的.
                onrefresh();
​
                registerlisteners();
​
                //实例化我们剩余的单实例bean.
                finishbeanfactoryinitialization(beanfactory);
​
                // 最后容器刷新 发布刷新事件(spring cloud也是从这里启动的)
                finishrefresh();
            }
​
            catch (beansexception ex) {
                if (logger.iswarnenabled()) {
                    logger.warn("exception  encountered during context initialization - " +
                            "cancelling refresh attempt: " + ex);
                }
​
                // destroy already created singletons to avoid dangling resources.
                destroybeans();
​
                // reset 'active' flag.
                cancelrefresh(ex);
​
                // propagate exception to caller.
                throw ex;
            }
​
            finally {
                // reset common introspection caches in spring's core, since we
                // might not ever need metadata for singleton beans anymore...
                resetcommoncaches();
            }
        }
    }

到此这篇关于传统tomcat启动服务与springboot启动内置tomcat服务的区别的文章就介绍到这了,更多相关tomcat启动服务与springboot启动内置tomcat服务区别内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！