精华内容
下载资源
问答
  • tomcat原理
    千次阅读
    2022-03-17 19:33:05


    本次的spring-boot-starter-parent版本为2.3.0。

    之前分析了Spring boot的启动源码的大概流程,结尾我们说了一些内嵌tomcat原理的原理,现在我们来深入探究一下!

    1 ServletWebServerFactoryConfiguration

    实际上,spring boot是指出多种服务器启动的,并不只是tomcat,还有jetty等。因此我们可以猜测具体哪种服务器是可以配置的,而spring boot又是以自动配置闻名,那么这些服务器肯定与某些自动配置类相关。

    实际上,spring boot的servlet web服务器的配置类就是位于spring-boot-autoconfigure.jar下的/META-INF/spring.factories文件中的一个名为ServletWebServerFactoryAutoConfiguration的自动配置类。

    在该自动配置类中,会通过@Import想容器中注入四个配置类,我们可以看到,各种容器的web服务配置,Tomcat、Jetty、Undertow,其中Tomcat对应EmbeddedTomcat。

    在这里插入图片描述

    这个EmbeddedTomcat配置类又会向Spring容器注入TomcatServletWebServerFactory,这个类就是Tomcat启动的关键类,用于创建TomcatWebServer。

    在这里插入图片描述

    另外,ServletWebServerFactoryAutoConfiguration中还会注入一系列的Customizer,用于修改内嵌Tomcat的参数和配置。

    在这里插入图片描述

    2 onRefresh启动web服务

    那么,这个TomcatServletWebServerFactory是怎么在什么时候被加载到容器中并使用的呢?Tomcat又是什么时候被启动的呢?

    之前的文章就讲过,在spring boot容器启动过程中,在创建容器之后,会执行刷新容器的操作,也就是refresh()操作,这个操作实际上就是spring容器的启动方法,将会加载bean以及各种配置。该方法是spring项目的核心方法,源码非常多,我们在之前以及花了大量时间讲过了,在此不再赘述,之前的文章链接Spring IoC容器初始化源码

    在refresh()方法中,有一个onRefresh()方法。

    在这里插入图片描述

    这个onRefresh方法默认是一个空的实现,这是留给子类容器实现的扩展方法。这个方法是在所有的bean定义被注入到容器中之后调用的,而在onRefresh方法之后,则会对所有的普通单例bean进行实例化和初始化。

    默认的web服务容器是AnnotationConfigServletWebServerApplicationContext,它又继承了ServletWebServerApplicationContext,该类就对onRefresh方法进行了实现,并且Spring boot的web服务器就是在此启动的!

    /**
     * ServletWebServerApplicationContext实现的方法
     */
    @Override
    protected void onRefresh(){
       //调用父类的逻辑
       super.onRefresh();
       try{
          /*
           * 关键方法,创建webserver
           */
          createWebServer();
       }
       catch( Throwable ex ){
          throw new ApplicationContextException( "Unable to start web server", ex );
       }
    }
    

    可以看到,内部调用了createWebServer方法创建web服务器。

    2.1 createWebServer创建web服务

    createWebServer方法的代码如下,它会通过之前配置的ServletWebServerFactory,获取webServer,即创建web服务器。

    一般我们使用的ServletWebServerFactory就是TomcatServletWebServerFactory,使用的webserver就是TomcatWebServer。

    在创建了webserver之后,会想容器注入两个SmartLifecycle类型的bean实例,这实际上是一个扩展点的实例,用于实现容器回调。

    其中,注册的WebServerStartStopLifecycle实例,在ServletWebServerApplicationContext类型的容器启动完毕后会调用该实例的start方法启动webServer并发送事件,在ServletWebServerApplicationContext类型的容器销毁时将会调用该实例的stop方法销毁webServer。

    private volatile WebServer webServer;
    
    /**
     * ServletWebServerApplicationContext的方法
     * <p>
     * 创建web服务
     */
    private void createWebServer(){
       //获取WebServer,这里默认是空的
       WebServer webServer = this.webServer;
       //获取ServletContext,即servlet上下文,这里默认是空的
       ServletContext servletContext = getServletContext();
       /*
        * 获取webServer,初始化web服务
        */
       if( webServer == null && servletContext == null ){
          //获取web服务工厂,默认就是TomcatServletWebServerFactory
          ServletWebServerFactory factory = getWebServerFactory();
          /*
           * 通过web服务工厂获取web服务,核心代码
           * 创建内嵌的Tomcat并启动
           */
          this.webServer = factory.getWebServer( getSelfInitializer() );
          /*
           * 注册WebServerGracefulShutdownLifecycle的实例到容器中
           * ReactiveWebServerApplicationContext容器启动完毕后会调用该实例的start方法
           * ReactiveWebServerApplicationContext容器销毁时将会调用该实例的stop方法
           */
          getBeanFactory().registerSingleton( "webServerGracefulShutdown", new WebServerGracefulShutdownLifecycle( this.webServer ) );
          /*
           * 注册WebServerStartStopLifecycle的实例到容器中
           * ServletWebServerApplicationContext容器启动完毕后会调用该实例的start方法尝试启动webServer并发送事件
           * ServletWebServerApplicationContext容器销毁时将会调用该实例的stop方法销毁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 );
          }
       }
       //初始化ConfigurableWebEnvironment类型的配属数据源
       initPropertySources();
    }
    

    2.1.1 getWebServerFactory获取web服务工厂

    该方法获取web服务工厂,工厂用于创建web服务。

    /**
     * ServletWebServerApplicationContext的方法
     * <p>
     * 获取ServletWebServerFactory,用于初始化webServer
     * 默认返回TomcatServletWebServerFactory
     */
    protected ServletWebServerFactory getWebServerFactory(){
       //从容器中搜索ServletWebServerFactory类型的beanName数组
       //之前的ServletWebServerFactoryConfiguration配置类就会像容器中
       //注入ServletWebServerFactory的bean,默认就是TomcatServletWebServerFactory
       String[] beanNames = getBeanFactory().getBeanNamesForType( ServletWebServerFactory.class );
       //没有web服务工厂
       if( beanNames.length == 0 ){
          throw new ApplicationContextException(
                "Unable to start ServletWebServerApplicationContext due to missing " + "ServletWebServerFactory bean." );
       }
       //有多个web服务工厂
       if( beanNames.length > 1 ){
          throw new ApplicationContextException(
                "Unable to start ServletWebServerApplicationContext due to multiple " + "ServletWebServerFactory beans : " + StringUtils.arrayToCommaDelimitedString(
                      beanNames ) );
       }
       //从容器中获取web服务工厂的实例
       return getBeanFactory().getBean( beanNames[ 0 ], ServletWebServerFactory.class );
    }
    

    2.1.2 getWebServer获取web服务

    ServletWebServerFactory的方法,用于获取web服务。其中TomcatServletWebServerFactory的方法用于创建Tomcat实例并返回TomcatServer。

    该方法中的一些名词比如baseDir、connector、Service、Host、AutoDeploy 、Engine等等都是Tomcat中的概念,我们之前就介绍过了,在此不再赘述:Tomcat的核心组件以及server.xml配置全解【一万字】

    在最后的getTomcatWebServer方法中会对Tomcat服务器进行启动。控制台会输出日志:Tomcat initialized with port(s): 8080 (http)。

    /**
     * TomcatServletWebServerFactory的方法
     * 创建内嵌的Tomcat
     *
     * @param initializers 初始化器
     * @return Tomcat的web服务
     */
    @Override
    public WebServer getWebServer( ServletContextInitializer... initializers ){
    
       if( this.disableMBeanRegistry ){
          Registry.disableRegistry();
       }
       //创建Tomcat实例
       Tomcat tomcat = new Tomcat();
       //设置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 );
       }
       //准备上下文
       prepareContext( tomcat.getHost(), initializers );
       //创建TomcatWebServer,启动Tomcat,返回TomcatWebServer
       return getTomcatWebServer( tomcat );
    }
    

    Tomcat启动后的继续执行Spring的逻辑,初始化bean实例等等,Spring容器初始化完毕之后,调用WebServerStartStopLifecycle的start方法,对TomcatWebServer进行启动,此时控制台会输出日志:Tomcat started on port(s): 8080 (http) with context path ‘’。

    相关文章:

    1. https://spring.io/
    2. Spring Framework 5.x 学习
    3. Spring MVC 5.x 学习
    4. Spring Framework 5.x 源码

    如有需要交流,或者文章有误,请直接留言。另外希望点赞、收藏、关注,我将不间断更新各种Java学习博客!

    更多相关内容
  • TOMCAT原理

    2022-03-09 21:50:57
    一、TOMCAT的基本架构 二、Coyote连接器 三、Catalina容器 四、启动流程介绍 五、请求处理流程介绍 六、Jasper引擎 七、服务器配置 1、Server、Service 2、Executor 3、Connector 4、Engine、Host 5、...

    一、TOMCAT的基本架构

    1、servlet基本架构

    由servlet容器加载servlet类,决定调用哪个servlet也就是业务类。整体遵守的就是servlet规范。

    2、Servlet容器工作流程

    当请求由http服务器转发给Servlet容器后,servlet会根据url的映射关系,定位到servlet。

    • 定位servlet
    • 加载servlet
    • 调用servlet

    3、tomcat架构

    两部分核心:

    1. 处理socket连接,负责处理网络请求 - Connector
    2. 加载和管理servlet,以及处理request请求 - Container

    二、Coyote连接器

    1、Coyote

    Coyote作为独立的模块,只负责集体协议和IO操作,与Servlet规范没有直接关系,因此Request和Response也与Servlet没有关系。这样就做到了组件之间的解藕。

    支持的IO模型:

    • NIO:非阻塞IO,采用java NIO类库实现
    • NIO2:一步IO,采用JDK7最新的NIO2类库实现
    • APR:采用apache的可以值类库实现

    支持的应用层协议:

    • HTTP1.1:这是大部分web采用的访问协议
    • AJP:用于和Web服务器即成,以实现对静态资源的优化和集群部署
    • HTTP2:下一代HTTP协议,性能大幅度提升

    tomact容器支持多种IO模型和应用层模型。每个容器可以连接多个Coyote。所以一个coyote+catalina才能对外提供服务,也就是一个service。

    2、Coyote组件的架构

    1. EndPoint:接受socket请求,发送给Processor
    2. Processor:将socket请求,封装为http请求,request转发给Adapter
    3. Adapter:由适配器将request对象封装成servletRequest转发给容器
    4. ProtocolHandler: EndPoint+Processor

    三、Catalina容器

    1、Catalina容器

    Catalina是Tomcat的servlet容器。包含了后面涉及到的安全、会话、集群、管理的Servlet容器架构的各个方面。

    Tomcat本身就是一个servlet容器,所以Catalina就是tomcat的核心。其它的模块都是为Catalina容器进行提供服务的。 

    2、Catalina结构

    • Catalina:负责解析Tomcat配置文件,以此来创建服务器Server组件,并根据命令管理
    • Server:表示整个Catalina Servlet容器及其它组件,负责启动Servlet引擎,tomcat连接器
      • Service:将Connector和Container绑定到一期
        • Connector:连接器
        • Container:servlet容器

    3、Container结构

    Container包含了Engine、Host、Context、Wapper,它们不是平行关系,而是父子关系。

    • Engine:表示整个Catalina的Servlet的引擎,一个Service只能包含一个Engine
    • Host:代表一个虚拟主机或者一个站点,可以个给Tomcat配置多个虚拟主机
    • Context:代表一个web应用,一个应用可以有多个Context
    • Wapper: 代表一个Servlet

    其实在server.xml中就包含了以上的各个组件和它们之间的关系。

    四、启动流程介绍

    父组件启动同时调用子组件的启动方法。记载tomcat的配置文件,初始化容器组件,监听对应的端口号,准备接受客户端请求。

    在tomcat,所有的功能都被抽象成组件,他们都有一个统一的接口,就是Lifecycle接口,它的核心方法有:

    • init():初始化组件
    • start():启动组件
    • stop():停止组件
    • destroy():销毁组件

    个组件默认实现如下:

    五、请求处理流程介绍

    1、请求处理流程

    tomcat是使用mapper组件,进行请求的映射。可以看成是一个多层次的map。

     

    六、Jasper引擎

    1、简介

    主要作用就是解析jsp页面,然后生成class字节码,向浏览器输出HTML。由于使用的越来越少了,在这里就不进行过多介绍。

    2、编译方式

    • 运行时编译:请求第一次的时候,进行编译
    • 预编译:启动项目的时候,直接编译完成

    七、服务器配置

    1、核心配置文件server.xml

    是tomcat服务器的核心配置文件,包含了tomcat中servlet(Catalina)容器的全部配置。

    • Server:根标签,配置关闭端口,配置相关的监听器、全局命名和多个Service
    • Service:服务名字就是Catalina,可以配置多个连接器、一个Engine
    • Executor:配置tomcat线程池相关内容,如果配置则多个连接器使用一个,否则每个连接器使用自己的线程池
    • Connector:连接器,可以配置port、protocol、conectionTimeout、redirectProt(https)、executor、encoding
    • Engine:name、defaultHost(默认主机)、jvm(使用的虚拟机)
    • Host:name、appBase(部署路径)、unpackWARs(是否解压WAR包)、autoDeploy(是否自动部署)
    • Context:虚拟主机中的项目
    展开全文
  • Tomcat原理与实战

    2020-08-27 22:46:44
    Tomcat 原理与实战 ppt内容pdf文档
  • Tomcat原理

    千次阅读 多人点赞 2019-04-19 10:19:13
    Tomcat顶层架构 Tomcat的顶层结构图: 1、Tomcat中最顶层的容器是Server,代表着整个服务器,一个Server可以包含至少一个Service,用于具体提供服务。 2、Service主要包含两个部分:Connector和Container。 ...

    Tomcat顶层架构

    Tomcat的顶层结构图:

    1、Tomcat中最顶层的容器是Server,代表着整个服务器,一个Server可以包含至少一个Service,用于具体提供服务。

    2、Service主要包含两个部分:Connector和Container。 Tomcat 的心脏就是这两个组件,这两个组件的作用:Connector用于处理连接相关的事情,并提供Socket与Request和Response相关的转化;Container用于封装和管理Servlet,以及具体处理Request请求。

    3、一个Tomcat中只有一个Server,一个Server可以包含多个Service,一个Service只有一个Container,但是可以有多个Connectors,因为一个服务可以有多个连接,如同时提供Http和Https链接,也可以提供向相同协议不同端口的连接。

    4、多个 Connector 和一个 Container 就形成了一个 Service,有了 Service 就可以对外提供服务了,但是 Service 还要一个生存的环境,必须要有人能够给她生命、掌握其生死大权,那就非 Server 莫属了!所以整个 Tomcat 的生命周期由 Server 控制。另外,上述的包含关系或者说是父子关系,都可以在tomcat的conf目录下的server.xml配置文件中看出。

    5、Server标签设置的端口号为8005,shutdown=”SHUTDOWN” ,表示在8005端口监听“SHUTDOWN”命令,如果接收到了就会关闭Tomcat。一个Server有一个Service,当然还可以进行配置,一个Service有多个,Service左边的内容都属于Container的,Service下边是Connector。

    Server处理HTTP请求

    原理图

    1.用户在浏览器中输入该网址,请求被发送到本机端口8080,被在那里监听的Coyote HTTP/1.1 Connector获得;

    2.Connector把该请求交给它所在的Service的Engine(Container)来处理,并等待Engine的回应;

    3.Engine获得请求localhost/test/index.jsp,匹配所有的虚拟主机Host;

    4.Engine匹配到名为localhost的Host(即使匹配不到也把请求交给该Host处理,因为该Host被定义为该Engine的默认主机),名为localhost的Host获得请求/test/index.jsp,匹配它所拥有的所有Context。Host匹配到路径为/test的Context(如果匹配不到就把该请求交给路径名为“ ”的Context去处理);

    5.path=“/test”的Context获得请求/index.jsp,在它的mapping table中寻找出对应的Servlet。Context匹配到URL Pattern为*.jsp的Servlet,对应于JspServlet类;

    6.构造HttpServletRequest对象和HttpServletResponse对象,作为参数调用JspServlet的doGet()或doPost(),执行业务逻辑、数据存储等;

    7.Context把执行完之后的HttpServletResponse对象返回给Host;

    8.Host把HttpServletResponse对象返回给Engine;

    9.Engine把HttpServletResponse对象返回Connector;

    10.Connector把HttpServletResponse对象返回给客户Browser。

    Connector架构分析

    Connector用于接受请求并将请求封装成Request和Response,然后交给Container进行处理,Container处理完之后在交给Connector返回给客户端。Connector的结构图:

    Connector就是使用ProtocolHandler来处理请求的,不同的ProtocolHandler代表不同的连接类型,比如:Http11Protocol使用的是普通Socket来连接的,Http11NioProtocol使用的是NioSocket来连接的。其中ProtocolHandler由包含了三个部件:Endpoint、Processor、Adapter:

    (1)Endpoint用来处理底层Socket的网络连接,Processor用于将Endpoint接收到的Socket封装成Request,Adapter用于将Request交给Container进行具体的处理。

    (2)Endpoint由于是处理底层的Socket网络连接,因此Endpoint是用来实现TCP/IP协议的,而Processor用来实现HTTP协议的,Adapter将请求适配到Servlet容器进行具体的处理。

    (3)Endpoint的抽象实现AbstractEndpoint里面定义的Acceptor和AsyncTimeout两个内部类和一个Handler接口。Acceptor用于监听请求,AsyncTimeout用于检查异步Request的超时,Handler用于处理接收到的Socket,在内部调用Processor进行处理。

    Container架构分析

    Container用于封装和管理Servlet,以及具体处理Request请求,在Connector内部包含了4个子容器,结构图如下(图C):

     

    4个子容器的作用分别是:

    (1)Engine:引擎,用来管理多个站点,一个Service最多只能有一个Engine;
    (2)Host:代表一个站点,也可以叫虚拟主机,通过配置Host就可以添加站点;
    (3)Context:代表一个应用程序,对应着平时开发的一套程序,或者一个WEB-INF目录以及下面的web.xml文件;
    (4)Wrapper:每一Wrapper封装着一个Servlet;

    下面找一个Tomcat的文件目录对照一下,如下图所示:

    Context和Host的区别是Context表示一个应用,我们的Tomcat中默认的配置下webapps下的每一个文件夹目录都是一个Context,其中ROOT目录中存放着主应用,其他目录存放着子应用,而整个webapps就是一个Host站点。

    我们访问应用Context的时候,如果是ROOT下的则直接使用域名就可以访问,例如:www.hern.com,如果是Host(webapps)下的其他应用,则可以使用http://www.hern.com/docs进行访问,当然默认指定的根应用(ROOT)是可以进行设定的,只不过Host站点下默认的主营用是ROOT目录下的。

    Container处理请求

     Container处理请求是使用Pipeline-Valve管道来处理的!(Valve是阀门之意)Pipeline-Valve是责任链模式,责任链模式是指在一个请求处理的过程中有很多处理者依次对请求进行处理,每个处理者负责做自己相应的处理,处理完之后将处理后的请求返回,再让下一个处理着继续处理。但是Pipeline-Valve使用的责任链模式和普通的责任链模式有些不同,区别主要有以下两点:

    (1)每个Pipeline都有特定的Valve,而且是在管道的最后一个执行,这个Valve叫做BaseValve,BaseValve是不可删除的;

    (2)在上层容器的管道的BaseValve中会调用下层容器的管道。

    Container包含四个子容器,而这四个子容器对应的BaseValve分别在:StandardEngineValve、StandardHostValve、StandardContextValve、StandardWrapperValve。

    Pipeline的处理流程图如下(图D):

    (1)Connector在接收到请求后会首先调用最顶层容器的Pipeline来处理,这里的最顶层容器的Pipeline就是EnginePipeline(Engine的管道);

    (2)在Engine的管道中依次会执行EngineValve1、EngineValve2等等,最后会执行StandardEngineValve,在StandardEngineValve中会调用Host管道,然后再依次执行Host的HostValve1、HostValve2等,最后在执行StandardHostValve,然后再依次调用Context的管道和Wrapper的管道,最后执行到StandardWrapperValve。

    (3)当执行到StandardWrapperValve的时候,会在StandardWrapperValve中创建FilterChain,并调用其doFilter方法来处理请求,这个FilterChain包含着我们配置的与请求相匹配的Filter和Servlet,其doFilter方法会依次调用所有的Filter的doFilter方法和Servlet的service方法,这样请求就得到了处理!

    (4)当所有的Pipeline-Valve都执行完之后,并且处理完了具体的请求,这个时候就可以将返回的结果交给Connector了,Connector在通过Socket的方式将结果返回给客户端。

    Connector和Container的微妙关系

    当一个请求发送到Tomcat之后,首先经过Service然后会交给Connector,Connector用于接收请求并将接收的请求封装为Request和Response来具体处理,Request和Response封装完之后再交由Container进行处理,Container处理完请求之后再返回给Connector,最后在由Connector通过Socket将处理的结果返回给客户端,这样整个请求的就处理完了!

    Connector最底层使用的是Socket来进行连接的,Request和Response是按照HTTP协议来封装的,所以Connector同时需要实现TCP/IP协议和HTTP协议!

    Tomcat顶层架构小结

    (1)Tomcat中只有一个Server,一个Server可以有多个Service,一个Service可以有多个Connector和一个Container;
    (2) Server掌管着整个Tomcat的生死大权;
    (4)Service 是对外提供服务的;
    (5)Connector用于接受请求并将请求封装成Request和Response来具体处理;
    (6)Container用于封装和管理Servlet,以及具体处理request请求;

    展开全文
  • tomcat服务程序里的conf里,web,tomcat-users,server等文件的详细讲解
  • 1.嵌入式Tomcat 懂得SpringBoot的童鞋应该很清楚,对于SpringBoot应用来说,不管应用程序是属于何种类型,都是一个Main方法走遍天下,而且对于web应用,只需要引入spring-boot-starter-web中这个依赖,应用程序就...

    1.嵌入式Tomcat

    懂得SpringBoot的童鞋应该很清楚,对于SpringBoot应用来说,不管应用程序是属于何种类型,都是一个Main方法走遍天下,而且对于web应用,只需要引入spring-boot-starter-web中这个依赖,应用程序就好像直接给我们来了个tomcat一样,其实,这里并不是SpringBoot团队里面有什么骚操作,而是Tomcat本身提供的外部接口,使其它应用程序能够非常方便的将Tomca嵌入t到自身的应用来。
    对于嵌入式Tomcat,其实也非常简单,就是调用Tomcat提供的外部类org.apache.catalina.startup.Tomcat而已,下面,我们通过代码来简单描述一下,如何在我们自身的程序嵌入Tomcat。
    maven依赖

      <dependency>
                <groupId>org.apache.tomcat.maven</groupId>
                <artifactId>tomcat7-maven-plugin</artifactId>
                <version>2.2</version>
      </dependency>
    

    简单的一个servlet

    public class DemoServlet extends HttpServlet {
    
        private static final long serialVersionUID = 1L;
    
        @Override
        public void doGet(HttpServletRequest request,
                          HttpServletResponse response)
                throws IOException, ServletException {
            response.setContentType("text/html");
            response.setCharacterEncoding("UTF-8");
            PrintWriter out = response.getWriter();
    
            out.println("<!DOCTYPE html><html>");
            out.println("<head>");
            out.println("<meta charset="UTF-8" />");
            out.println("<title></title>");
            out.println("</head>");
            out.println("<body bgcolor="white">");
            out.println("<h1> 嵌入式tomcat</h1>");
            out.println("</body>");
            out.println("</html>");
        }
    }
    

    EmbeddedTomcatServer 嵌入式Tomat入口:

    public class EmbeddedTomcatServer {
        public static void main(String[] args) throws Exception {
            //把目录的绝对的路径获取到
            String classpath = System.getProperty("user.dir");
            System.out.println(classpath);
            //new一个Tomcat
            Tomcat tomcat = new Tomcat();
    
            //插件是6或者6以前的
            //Embbedded
            //设置Tomcat的端口
            //tomcat.setPort(9090);
            Connector connector = tomcat.getConnector();
            connector.setPort(9091);
            //设置Host
            Host host = tomcat.getHost();
            //我们会根据xml配置文件来
            host.setName("localhost");
            host.setAppBase("webapps");
            //前面的那个步骤只是把Tomcat起起来了,但是没啥东西
            //要把class加载进来,把启动的工程加入进来了
            Context context = tomcat.addContext(host, "/", classpath);
    
            if (context instanceof StandardContext) {
                StandardContext standardContext = (StandardContext) context;
                standardContext.setDefaultContextXml("E:\apache-tomcat-8.5.51\conf\web.xml");
                //我们要把Servlet设置进去
                Wrapper wrapper = tomcat.addServlet("/", "DemoServlet", new DemoServlet());
                wrapper.addMapping("/embeddedTomcat");
            }
            //Tomcat跑起来
            tomcat.start();
            //强制Tomcat server等待,避免main线程执行结束后关闭
            tomcat.getServer().await();
        }
    
    }
    

    运行结果:
    在这里插入图片描述
    EmbeddedTomcatServer类作为程序的入口,代码逻辑其实就是通过tomcat提供的外部接口类在配置server.xml这个文件;要了解这个类的每个配置步骤,可能需要对tomcat相关组件有一定的理解,如下所示,对于每个组件的作用,博主画了一个图进行简单的介绍
    在这里插入图片描述
    对于Tomcat源码的构建,有兴趣的童鞋可参考这篇文章:https://www.jb51.net/article/95120.htm

    2. Spring内嵌Tomcat原理剖析

    其实SpringBoot嵌入Tomcat等其它web容器,关键是在类ServletWebServerApplicationContext的onRefresh方法,如下为该方法的代码定义:
    在这里插入图片描述
    继续进入createWebServer()方法
    在这里插入图片描述
    进入TomcatServletWebServerFactory#getWebServer()方法。如下所示
    在这里插入图片描述
    通过上面流程分析,可以发现,SpringBoot嵌入Tomcat也是通过调用Tomcat提供的外部类org.apache.catalina.startup.Tomcat进行开发的。

    展开全文
  • idea 启动tomcat 原理 首先我们需要知道两个变量对应的含义 CATALINA_HOME是Tomcat的安装目录 CATALINA_BASE是Tomcat的工作目录 我们来观察 tomcat 的 startup.bat启动和 idea 启动的区别 发现了吗 ,只有CATALINA_...
  • tomcat原理

    2012-11-23 20:06:15
    该文档为英文文档,以tomcat6为例进行讲解
  • 想要了解tomcat 原理我们首先要了解tomcat是什么,有什么功能,在什么地方起作用? 一、网卡 首先我们知道如果一台计算机如果想要其他计算机交换数据的话,必须要走网卡的端口交换数据。网卡能够把把物理电信号...
  • Springboot内置Tomcat原理

    2020-09-08 11:12:30
    SpringBoot的启动主要是通过实例化SpringApplication来启动的,启动过程主要做了以下几件事情:配置属性...而tomcat的启动主要是实例化两个组件:Connector、Container,一个tomcat实例就是一个Server,一个Server包含
  • (三)IDEA部署Tomcat原理

    千次阅读 2019-03-30 00:11:14
    IDEA部署Tomcat原理 上一篇文章部署成功后,我们来对比一下IDEA运行服务器与直接运行服务器有什么异同? IDEA运行如下: 手动运行服务器操作如下 打开命令行窗口cmd,如果你没有配置环境变量的话,进入到安装...
  • spring boot启动加载tomcat原理深度剖析

    千次阅读 2022-03-05 12:26:00
    spring boot应用打包成Fat jar时,启动内嵌tomcat原理;spring boot应用打包成WAR时,外部tomcat启动spring boot SpringApplication的原理;自动化配置Servlet/ServletFilter/ServletListener的原理
  • 揭秘springboot集成tomcat原理

    千次阅读 2020-12-28 22:46:54
    在这里先抛出一些原生Tomcat作为web服务器的知识,Tomcat称之为web容器,也可以称之为servlet容器,原因如下: web容器:用来与我们的浏览器做交互,即与http请求做交互 servlet容器:与http请求做交互的时候,如何...
  • jetty,tomcat原理

    2018-08-25 10:36:09
    这边主要是对tomcat和jetty两个容器的相关实现原理进行整理,主要资源来自网络,作者只是起到整理的作用,这一块也是希望分享出去,给即将面临面试的同学一些帮助,希望所有人都能入职心仪的公司。
  • IDEA部署tomcat原理小解

    2020-02-20 11:26:31
    IDEA部署tomcat原理小解 最近看到一个视频对IDEA部署启动tomcat有了新的理解。下面和大家分享一下。 1.tomcat部署项目的三种方式 在纯tomcat环境下,不使用开发工具tomcat部署项目有三种方式。 ①把html放到tomcat...
  • Tomcat原理解析

    2012-02-23 13:43:36
    文档描述了Tomcat加载流程,启动流程的类图,分析了Tomcat框架的基本架构和原理
  • 适合读者 1.jsp/servlet 开发人员,想了解 tomcat 内部机制的 coder; 2.想加入 tomcat 开发团队的 coder; 3.web 开发人员,但对软件开发很有兴趣的 coder; 4.想要对 tomcat 进行定制的 coder。
  • Tomcat原理(web中间件的一些思考)

    千次阅读 2020-09-17 12:15:49
    所以spring-boot-starter-web 主要体现在 创建 并配置Tomcat 实例,具体参见 7、SpringBoot 中内嵌 Tomcat 的实现原理解析 Tomcat如何支持异步Servlet? 从上文类图可知,NioEndpoint中有一个Executor,selector....
  • JavaWeb Tomcat原理理解

    千次阅读 2018-07-17 21:49:15
    Tomcat:  Tomcat是一个JSP/Servlet容器。其作为Servlet容器,有三种工作模式:独立的Servlet容器、进程内的Servlet容器和进程外的Servlet容器。 Tomcat目录: tomcat  |—bin:存放启动和关闭tomcat脚本  |...
  • 浅析tomcat原理

    千次阅读 2018-11-24 03:01:26
    浅析tomcat原理 上上个星期,看了一下how tomcat works这本书,今天捡起来看一会,发现忘得有点快,特地写点东西,加深一下记忆。因为书讲的是tomcat4,5的内容,比较旧了,所以和最新的tomcat的差距还是有点大的。...
  • jsvc启动tomcat原理

    2015-08-10 14:12:23
    jsvc启动tomcat原理详细说明,更安全的启动tomcat的方式。
  • springBoot零配置原理与内嵌tomcat原理

    千次阅读 2020-03-20 15:05:24
    代码启动tomcat Tomcat tomcat = new Tomcat(); tomcat.setPort(9980); try{ tomcat.start(); tomcat.getServer().await(); }catch(LifecyleException e){ e.printStackTrace(); } 酱紫就可以启动内嵌tomcat了,但是...
  • tomcat + spring mvc 原理(一):tomcat原理综述tomcat + spring mvc的运作模式tomcat内部的基本容器构成tomcat容器对应的外部配置     tomat + spring mvc 是目前比较流行java微服务体系架构...
  • Tomcat原理简述

    千次阅读 2018-12-20 15:15:24
    Tomcat依赖/conf/server.xml这个配置文件启动server(一个Tomcat实例,核心就是启动容器Catalina)。 Tomcat部署Webapp时,依赖context.xml和web.xml(&lt;CATALINA_HOME&gt;/conf/目录下的context.xml和web...
  • 在本地eclipse上创建一个tomcat server即tomcat服务器时, 会复制一份tomca安装目录中的conf文件下的配置文件到这个tomcatserver目录下 这个tomcatserver目录在workspaces路径,跟其他project同路径 文件如下,这些...
  • tomcat的工作原理

    2021-05-20 21:05:51
    本文源自转载:你还记得 Tomcat 的工作原理么 一、Tomcat 整体架构 Tomcat 是一个免费的、开源的、轻量级的 Web 应用服务器。适合在并发量不是很高的中小企业项目中使用。 二、文件目录结构 以下是 Tomcat 8 ...
  • 作为一个web容器,请求在服务端的第一站,理解tomcat对我们今后理解spring,理解springmvc等等很多框架都有很大的帮助。
  • Tomcat工作原理

    2020-06-09 23:01:40
    Tomcat是什么 Tomcat 服务器是一个免费的开放源代码的Web 应用服务器,属于轻量级应用服务器,在中小型系统和并发访问用户不是很多的场合下被普遍使用,是开发和调试JSP 程序的首选。 web服务器按功能分类可分为:...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 148,033
精华内容 59,213
关键字:

tomcat原理