深入分析理解Tomcat体系结构

Tomcat整体结构

　　由上图可知Tomcat的顶层容器是Server,而且一个Tomcat对应一个Server,一个server有多个service提供服务.service包含两个重要组件:Connector和Container.这个后面详细讲解.这个Server由谁来管理呢?当然是Catalina了,她是tomcat的管理类,她的三个方法load,start,stop分别用来管理整个服务器的生命周期.

Load方法:Load方法根据conf/server.xml文件创建Server并调用Server的init方法进行初始化.Server的init方法调用所有service的init方法,service的init方法调用所有Connector和Container的init方法.整个初始化工作就完成了.

Start方法:用于启动服务,类似init,也是逐层进行启动.

Stop方法:用于关闭服务,类似init,也是逐层调用关闭.

最后,CatAlina中的await方法非常重要,这个方法调用Server中的await方法,这个方法的作用就是进入一个循环,保持主线程不退出.

Tomcat组件启动过程

Bootstrap的启动过程

Tomcat启动的入口方法就是Bootstrap中的main方法,代码如下:

 public static void main(String args[]) {
        if (daemon == null) {
            // Don't set daemon until init() has completed
            Bootstrap bootstrap = new Bootstrap();
            try {//初始化ClassLoader,创建了Catalina实例,赋值给catalinaDaemon
                bootstrap.init();
            } catch (Throwable t) {
                handleThrowable(t);
                t.printStackTrace();
                return;
            }
            daemon = bootstrap;
        } else {
            // When running as a service the call to stop will be on a new
            // thread so make sure the correct class loader is used to prevent
            // a range of class not found exceptions.
            Thread.currentThread().setContextClassLoader(daemon.catalinaLoader);
        }
        //根据args参数执行不同的命令
        try {
            String command = "start";//默认执行start
            if (args.length > 0) {
                command = args[args.length - 1];
            }
            if (command.equals("startd")) {
                args[args.length - 1] = "start";
                daemon.load(args);
                daemon.start();
            } else if (command.equals("stopd")) {
                args[args.length - 1] = "stop";
                daemon.stop();
            } else if (command.equals("start")) {
                daemon.setAwait(true);
                daemon.load(args);
                daemon.start();
            } else if (command.equals("stop")) {
                daemon.stopServer(args);
            } else if (command.equals("configtest")) {
                daemon.load(args);
                if (null==daemon.getServer()) {
                    System.exit(1);
                }
                System.exit(0);
            } else {
                log.warn("Bootstrap: command \"" + command + "\" does not exist.");
            }
        } catch (Throwable t) {
            // Unwrap the Exception for clearer error reporting
            if (t instanceof InvocationTargetException &&
                    t.getCause() != null) {
                t = t.getCause();
            }
            handleThrowable(t);
            t.printStackTrace();
            System.exit(1);
        }
}

public void start()
        throws Exception {
        if( catalinaDaemon==null ) init();

        Method method = catalinaDaemon.getClass().getMethod("start", (Class [] )null);
        method.invoke(catalinaDaemon, (Object [])null);

    }

调用执行start方法前,先判断catalinaDaemon有没有被初始化,如果没有则执行init方法,然后使用Method进行反射调用Catalina的start方法.

知识点补充:

Method是java.lang.reflect包里的类,可以使用其中的invoke方法来执行所代表的方法,invoke里有两个参数,第一个参数是Method方法所在的实体,第二个参数是可变参数,用于Method方法执行时所需要的参数.

Catalina的启动过程

Catalina的启动主要调用setAwait,load和start方法来完成.setAwait方法用于设置Server启动后是否进入等待状态的标志,为true进入,否则不进入.load方法用于加载配置文件,start方法用于启动服务器.

public void setAwait(boolean b) {
        await = b;
    }

public void load() {
        //...创建server
    try {
            getServer().init();
        } catch (LifecycleException e) {
            if (Boolean.getBoolean("org.apache.catalina.startup.EXIT_ON_INIT_FAILURE")) {
                throw new java.lang.Error(e);
            } else {
                log.error("Catalina.start", e);
            }

        }
        //...
    }

    /**
     * Start a new server instance.
     */
    public void start() {

        if (getServer() == null) {
            load();
        }

        if (getServer() == null) {
            log.fatal("Cannot start server. Server instance is not configured.");
            return;
        }

        long t1 = System.nanoTime();

        // Start the new server
        try {
            getServer().start();
        } catch (LifecycleException e) {
            log.fatal(sm.getString("catalina.serverStartFail"), e);
            try {
                getServer().destroy();
            } catch (LifecycleException e1) {
                log.debug("destroy() failed for failed Server ", e1);
            }
            return;
        }
        //...
        if (await) {
            await();
            stop();
        }
    }

Server的启动过程

　　Server接口中提供了addService(Service service),removeService(Service service)来增加和删除Service,Server中的init和start方法循环调用Service中的init和start方法来启动所有Service.Server的默认实现是StandardServer.

Service的启动过程

　　Service的默认实现是StandardService,和StandardServer一样也继承自LifecycleMBeanBase类,所以init和start方法最终会调用initInternal和startInternal方法.而StandardService中的initInternal和startInternal方法主要调用container,executors,mapperListener,connectors的init和start方法.

Tomcat声明周期管理

1.Lifecycle接口

　　Tomcat通过Lifecycle接口统一管理生命周期,所有生命周期组件都要实现这个接口,Lifecycle接口主要做了4件事:

1)       定义了13个String类型常量,用于LifecycleEvent事件的type属性中,作用是为了区分组件发出LifecycleEvent事件的状态.

2)       定义了3个管理监听器的方法addLifecycleListener,findLifecycleListener,removeLifecycleListener,分别用来添加,查找,删除LifecycleListener类型的监听器.

3)       定义了4个生命周期方法:init,start,stop和destroy,用于执行生命周期的各个阶段的操作.

4)       定义了获取当前状态的两个方法:getState和getStateName,用来获取当前的状态.

具体接口代码如下:

public interface Lifecycle {
    //13中LifecycleEvent事件的类型
    public static final String BEFORE_INIT_EVENT = "before_init";

    public static final String AFTER_INIT_EVENT = "after_init";

    public static final String START_EVENT = "start";

    public static final String BEFORE_START_EVENT = "before_start";

    public static final String AFTER_START_EVENT = "after_start";

    public static final String STOP_EVENT = "stop";

    public static final String BEFORE_STOP_EVENT = "before_stop";

    public static final String AFTER_STOP_EVENT = "after_stop";

    public static final String AFTER_DESTROY_EVENT = "after_destroy";

    public static final String BEFORE_DESTROY_EVENT = "before_destroy";

    public static final String PERIODIC_EVENT = "periodic";

    public static final String CONFIGURE_START_EVENT = "configure_start";

    public static final String CONFIGURE_STOP_EVENT = "configure_stop";

    //3个管理监听器的方法
    public void addLifecycleListener(LifecycleListener listener);

    public LifecycleListener[] findLifecycleListeners();

    public void removeLifecycleListener(LifecycleListener listener);

    //4个生命周期方法
    public void init() throws LifecycleException;

    public void start() throws LifecycleException;

    public void stop() throws LifecycleException;

    public void destroy() throws LifecycleException;

    //2个获取当前状态的方法
    public LifecycleState getState();

    public String getStateName();
}

2.LifecycleBase

　　LifecycleBase是Lifecycle的默认实现,所有实现了生命周期的组件都直接或间接的继承了LifecycleBase.LifecycleBase为Lifecycle里的接口方法提供了默认实现.监听器管理是专门提供了一个LifecycleSupport类来完成,在LifecycleSupport中定义了LifecycleListener类型的数组,用来保存所有监听器,并定义了添加,删除,查找,执行监听器的方法;生命周期中设置了相应的状态并调用了相应的模板方法,init,start,stop,destroy所对应的模板方法分别是initInternal,startInternal,stopInternal,destroyInternal方法,执行生命周期就是这4个方法.组件的当前状态在这4个方法中已经设置好了,所以直接返回就OK了.

Container分析

　　Container是Tomcat中容器的接口,通常使用的Servlet就封装在其子接口Wrapper中.Container一共有4个接口Engine,Host,Context,Wrapper和一个默认实现类ContainerBase,每个子接口都是一个容器,这四个容器都有一个对应的StandardXXX实现类,并且这些实现类都继承自ContainerBase类.Container还继承Lifecycle接口,而且ContainerBase间接继承LifecycleBase. 4个接口Engine,Host,Context,Wrapper也符合Tomcat的生命周期管理模式.

1.Container容器结构

2.4个容器的作用

Engine:引擎,用来管理多个站点,一个Service最多只能有一个Engine.

Host:代表一个站点,也可叫虚拟主机,通过配置Host来添加站点.

Context:代表一个应用程序,对应一套程序或者WEB-INF目录及下面的web.xml

Wraper:每个Wrapper封装着一个Servlet.

Pipeline-value管道

　　Container处理请求是使用Pipeline-value管道来处理的.Pipeline-value是责任链模式,区别于普通的责任链模式:

1)       每个Pipeline都有特定的Value,而且是在管道的最后执行,这个value叫做BaseValue,是不可删除的.

2)       在上层容器的BaseValue中会调用下层容器的管道.

Pipeline的实现方法

Pipeline管道的实现分为生命周期管理和处理请求两部分.

1.生命周期实现方法

Container中的Pipeline在抽象实现类ContainerBase中定义,并在生命周期的startInternal,stopInternal,destroyInternal方法中调用管道的相应生命周期方法.

2.处理请求实现方法

Pipeline调用所包含Value的invoke方法来处理请求,并且在BaseValue里又调用了子容器Pipeline所包含Value的invoke方法,直到最后调用了Wrapper的Pipeline所包含的BaseValue—StandardWrapperValue

Connector分析

　　Connector用于接收请求并将请求封装成Request和Response来具体处理,最底层是使用Socket来进行连接的,Request和Response是按照Http协议来封装的,所以Connector同时实现了TCP/IP协议和HTTP协议,Request和Response封装完之后交给Container进行处理,Container就是Servlet容器,Container处理完成之后返回给Connector,最后Connector使用Socket将处理结果返回给客户端,整个请求就完成了.

　　Connector中具体是用ProtocolHandler来处理请求,并且Connector的创建过程主要是初始化ProtocolHandler.不同的ProtocolHandler代表不同的连接类型.Http11Protocol使用的是普通的Socket来连接的.Http11NioProtocol使用的是NioSocket来连接的.

Protocol三个重要组件:

Endpoint:用于处理底层的Socket网络连接.

Processor:用于将Enpoint接收到的请求封装成Request

Adapter:用于将封装好的Request交给Container处理.

最近学习有些懈怠了,主要是工作太忙,下班后基本剩下上床睡觉了.无论如何还是要不断加强学习,提高自身技术水平.