Tomcat源码分析(零) : 整体架构

布满荆棘的人生 2022-05-15 02:44 337阅读 0赞

# Tomcat架构及其重要组件 #

![Tomcat的系统架构][Tomcat]

Tomcat的系统架构

*  Server是管理Service接口的，是Tomcat的一个顶级容器。管理着多个Service
 *  Service 是服务，管理这一个Container和多个Connector，Service的存在依赖于Server
 *  Container : 一个或者多个**Container** 可以对应一个Connector,这样就组成了一个Service，Service生命周期的由Server进行管理。
 *  Container和Connector之间的交互媒介是Service，一个Service可以对应多个Connector，但是只能有一个Container容器

### Server ###

*  Server 管理着所有的Service。它的主要作用是提供一个接口可以让其它程序能够访问这个Service集合，同时维护所有service的生命周期等。

Server在Tomcat中的标准实现是`StandardServer`。看一下其内部的`addServiec`方法

@Override
        //FIXME: 它是怎样调用起来Service 方法的哪？
        public void addService(Service service) {
    
            service.setServer(this);
            //同步
            synchronized (servicesLock) {
                
                Service results[] = new Service[services.length + 1];
                System.arraycopy(services, 0, results, 0, services.length);
                results[services.length] = service;
                services = results;
    
                if (getState().isAvailable()) {
                    try {
                        service.start();
                    } catch (LifecycleException e) {
                        // Ignore
                    }
                }
    
                // Report this property change to interested listeners
                support.firePropertyChange("service", null, service);
            }
    
        }

可以看到，在添加Service到Server的时候，它是将原有数组的长度加一并将数组添加到最后。然后启动最新添加的`Service`

### Service ###

Service 在Tomcat中的标准实现是`StandardService`,Service 可以说是一个标准的服务,拥有独立的端口号。  
在Service 中可以含有多个Connector和唯一的一个Container.这样的设计模式可以**允许 例如SSL加密过的请求和没有经过SSL加密的请求在一个APP中同时存在**

Service 中的`setContainer()`

@Override
        public void setContainer(Engine engine) {
            Engine oldEngine = this.engine;
            if (oldEngine != null) {
                // 移除原有Container
                oldEngine.setService(null);
            }
            this.engine = engine;
            if (this.engine != null) {
                this.engine.setService(this);
            }
            if (getState().isAvailable()) {
                if (this.engine != null) {
                    try {
                        //开启Engin
                        this.engine.start();
                    } catch (LifecycleException e) {
                        log.warn(sm.getString("standardService.engine.startFailed"), e);
                    }
                }
                // Restart MapperListener to pick up new engine.
                try {
                    mapperListener.stop();
                } catch (LifecycleException e) {
                    log.warn(sm.getString("standardService.mapperListener.stopFailed"), e);
                }
                try {
                    mapperListener.start();
                } catch (LifecycleException e) {
                    log.warn(sm.getString("standardService.mapperListener.startFailed"), e);
                }
                if (oldEngine != null) {
                    try {
                        oldEngine.stop();
                    } catch (LifecycleException e) {
                        log.warn(sm.getString("standardService.engine.stopFailed"), e);
                    }
                }
            }
    
            // Report this property change to interested listeners
            support.firePropertyChange("container", oldEngine, this.engine);
        }

Service 的`setContainer`方法设置Engine容器，然后启动这个容器，并将原有的容器的停止掉。Service 的`setConnector`几乎是同样的套路

### Container ###

Container 由四个子容器组成：

*  Engine : 表示整个Catalina Servlet引擎，是Container 只用最高层，用来管理Host 或者Context的实现
 *  如果你想拦截每一个到Servlet的请求，可以通过
 *  Host :表示一个Engine管理下的一个虚拟主机，比如你访问的Localhost就是一个虚拟主机。作用是运行多个应用  
    其处理过程可以总结如下：
    
    1.  为特定的请求URL选择一个Context容器
    2.  把Context容器绑定到线程中
    3.  判断是否是一个异步请求
    4.  让Context去处理这个请求
    5.  Context执行invoke方法，进入管道中，由**StandardContextValve**(是ContextValve的标准实现类)处理
 *  Context：Context 是用来管理Servlet的容器，Context就对应一个应用。所以我们部署应用时需要创建一个Context容器，Context负责管理Wrapper.
 *  Wrapper ： 用来管理一个Servlet的生命周期

### Connector ###

Connector 是Tomcat的连接器，主要任务是负责处理浏览器发送过来的请求，并创建一个Request和Response对象，用于和前端Client交换数据，然后产生一个线程，并将Request对象和Response对象传递给线程，后面对这两个线程的处理就是Container的事情了

1.  实例化Connector，构造一个Connector对象
2.  调用Connector的initIntenal方法，初始化Connetor
3.  调用ProtocolHanlder的init方法，完成ProtocolHanlder的初始化。这个过程包括了创建线程池并创建一个线程处理浏览器请求
4.  调用Connector的startIntenal方法，启动Connector
5.  调用ProtocolHandler的start方法，启动Protocolhanlder
6.  调用MapperListener的start方法，启动监听器程序

不同于Container ,Connector是一个实现类.其相当于一个容器处理基于Http的请求  
。**CoyoteAdapter**,是connector和container的桥梁,经过这一步，请求就从connector传递到container中里了。Adapter

要注意的是：最先处理请求的Request是org.apache.coyote.Request类型，这是一个Tomcat中一个轻量级对象，完成基本的请求处理后很容易被JVM回收，那为什么不直接交给Connector.Request对象处理呢？由于后者是Servlet容器真正传递的对象其完成的职责比前者复杂，这里使用org.apache.coyote.Request主要减轻后者的任务负担，出于性能考虑才这么设计。

从connector.getService().getContainer().getPipeline().getFirst().invoke(request, response);这句代码中可以知道下一步的处理需要交给Container容器了。

### Context容器和Wrapper ###

*  Wrapper 接口是Context的抽象接口
 *  Context的启动：
 *  Context的启动过程就是加载整个类资源文件和打开子容器，以及pipeline的过程。
 *  **StandardContextValve的invoke 方法**会通过request得到相应的ContextWrapper,在这个过程中如果没有发生异常，服务端会向client 发送一个ack响应
 *  StandardContext的处理流程可以用下面的图来简化：

![Image 1][]

*  StandardContext的addServlet会添加一个Servlet类,并通过Servlet名字分配一个ServletWrppar,如果没有则为其新建一个。通过这个Wrappar来管理这个Servlet。。
 *  Wrapper与Servlet息息相关，其中的loadServlet负责装载Servlet.Wrapper是最底层
 *  Standard类主要负责初始化一个Servlet实例，并调用该实例的init方法，然后通知感兴趣的事件监听程序。用了Wrapper的invoke方法，这个方法完成什么呢？

# 附录： 一个HTTP请求是怎样通过Tomcat到你的应用中的 #

**Http请求在Container中的传递流程**

![Image 1][]

作者：walker\_liu\_fei  
链接：https://www.jianshu.com/p/3ede935ce8fe  
來源：简书  
简书著作权归作者所有，任何形式的转载都请联系作者获得授权并注明出处。

[Tomcat]: /images/20220515/b23708c3526749d798a11ea0d7e5ade1.png
[Image 1]: