How tomcat works 读书笔记十四 服务器组件和服务组件

之前的项目还是有些问题的,例如

1 只能有一个连接器,只能处理http请求,无法添加另外一个连接器用来处理https。

2 对容器的关闭只能是粗暴的关闭Bootstrap。

服务器组件

org.apache.catalina.Server接口的实例用来表示Catalina的整个servlet引擎。

我们使用Server就是因为,它用一种优雅的方式来启动/关闭整个系统。

下面是启动和停止机制是如何工作的。当服务器启动的时候，它启动它内部的所有组件。然后无限期的等待关闭命令，如果你想要关闭系统，发送一个关闭命令道指定端口即可。当服务器收到正确的关闭指令后，它停止所有组件的服务。

服务器还使用了另外一个组件，即服务组件，它用来持有组件，例如容器或者一个多个的连接器。服务组件将在本章的 service 小节中介绍。(注意有服务器组件,也有服务组件,这两个是不一样的。)

Server接口中属性 shutdown 用来持有一个停止服务的指令。属性 port 则是服务器等待关闭命令的端口。可以调用服务器的 addService 方法将服务添加到服务器。使用removeService 方法将服务删除。findServices 返回所有服务器中所有的服务。

StandardServer类

StandardServer类是Server接口的标准实现。在这里,我们主要介绍它的四个方法。initialize(),start(),stop(),await();

我们一个一个来说。

initialize方法

public void initialize() throws LifecycleException {
        if (initialized)
            throw new LifecycleException (
                sm.getString("standardServer.initialize.initialized"));
        initialized = true;

        // Initialize our defined Services
        for (int i = 0; i < services.length; i++) {
            services[i].initialize();
        }
    }

我们能看到这里使用了一个initialized来标识服务器是否已经初始化,同时初始化它所包含的服务组件。

另外在stop中,initialized并没有更改,因此如果服务器先初始化,再关闭,等再次初始化的时候会抛出异常。

start方法

public void start() throws LifecycleException {

        // Validate and update our current component state
        if (started)
            throw new LifecycleException
                (sm.getString("standardServer.start.started"));
        // Notify our interested LifecycleListeners
    ...
        started = true;

        // Start our defined Services
        synchronized (services) {
            for (int i = 0; i < services.length; i++) {
                if (services[i] instanceof Lifecycle)
                    ((Lifecycle) services[i]).start();
            }
        }

        // Notify our interested LifecycleListeners
       ...
    }

和初始化干的事情差不多,循环启动它所关联的服务组件。另外在stop方法中,started会被置为false。

stop方法

public void stop() throws LifecycleException {
        // Validate and update our current component state
        if (!started)
            throw new LifecycleException
                (sm.getString("standardServer.stop.notStarted"));

        // Notify our interested LifecycleListeners
    ...
        started = false;

        // Stop our defined Services
        for (int i = 0; i < services.length; i++) {
            if (services[i] instanceof Lifecycle)
                ((Lifecycle) services[i]).stop();
        }

        // Notify our interested LifecycleListeners
       ...
    }

关闭所有的服务组件。

await方法

这里不再贴出代码,await做的事就是监听8005端口,如果用户给8005端口发来"SHUTDOWN"就关闭serverSocket,然后await方法就执行完了。

现在再说说initialize方法,start方法,await方法,stop四者者都是在Bootstrap里调用的。

当await方法执行完毕后,就会调用服务器的stop方法。

Service接口

org.apache.catalina.Service 接口用于表示服务。一个服务可以有一个容器和多个连接器。你可以添加多个连接器 ，并将它们跟容器相关联。

StandardService类

StandardService是Service接口的标准实现。

容器与连接器

一个 StandardService 实例包括两种组件：一个容器和多个连接器。多个连接器可以使得 Tomcat 能服务于多个协议。一个协议用处处理 HTTP 请求，另一个用于处理 HTTPS 请求。

StandardService 类用 container 变量来持有容器实例，用 connectors 数组来持有所有的连接器

private Container container = null;
private Connector connectors[] = new Connector[0];

要将一个容器跟一个服务相关联，可以使用它的 setContainer 方法，

在setContainer中,会把container传递给每一个connector。

synchronized (connectors) {
            for (int i = 0; i < connectors.length; i++)
                connectors[i].setContainer(this.container);
        }

要给一个服务添加连接器，可以使用 addConnector 方法。在添加连接器的同时也会初始化他们。

要删除一个连接器，可以使用 removeConnector 方法。

与生命周期相关的方法

这里主要包含三个方法,initialize,start,stop。

initialize功能就是调用所以连接器的initialize方法。

start功能就是启动容器和若干个连接器。

stop功能就是关闭容器和若干个连接器。

服务组件的这三个方法都会在服务器组件里相应的方法里被调用,而服务器组件的这三个方法是在Bootstrap里调用的。

应用程序

这里主要是两个类,一个是 Bootstrap 启动程序，另一个是 Stopper 类用来停止它。

Bootstrap类

public static void main(String args[]){
......

    Service service = new StandardService();
    service.setName("Stand-alone Service");

    Server server = new StandardServer();
    server.addService(service);      //把服务组件添加到服务器组件里
    service.addConnector(connector); //把连接器关联到服务组件里

    //StandardService class's setContainer will call all its connector's setContainer method
    service.setContainer(engine);    //容器并没有直接和连接器关联,而是和服务组件关联

    // Start the new server
    if (server instanceof Lifecycle) {
      try {
        server.initialize();         //调用initialize,start,await方法
        ((Lifecycle) server).start();//这里会调用服务组件的start,来调用连接器与容器的start
                                 //连接器会在8080上等待消息....
        server.await();              //除非在8005端口收到了SHUTDOWN信息 这里会一直循环
        // the program waits until the await method returns,
        // i.e. until a shutdown command is received.
      }
      catch (LifecycleException e) {
        e.printStackTrace(System.out);
      }
    }

    // Shut down the server
    if (server instanceof Lifecycle) {
      try {
        ((Lifecycle) server).stop();  //收到了SHUTDOWM信息,关闭服务器组件
      }
      catch (LifecycleException e) {
        e.printStackTrace(System.out);
      }
    }
  }

Stopper类

public class Stopper {

  public static void main(String[] args) {
    // the following code is taken from the Stop method of
    // the org.apache.catalina.startup.Catalina class
    int port = 8005;
    try {
      Socket socket = new Socket("127.0.0.1", port);
      OutputStream stream = socket.getOutputStream();
      String shutdown = "SHUTDOWN";
      for (int i = 0; i < shutdown.length(); i++)
        stream.write(shutdown.charAt(i));
      stream.flush();
      stream.close();
      socket.close();
      System.out.println("The server was successfully shut down.");
    }
    catch (IOException e) {
      System.out.println("Error. The server has not been started.");
    }
  }
}