How Tomcat work 之第十四章之service



Service

org.apache.catalina.Service 这个接口表示一个Service。一个Service可以拥有一个容器和多个连接器。你可以添加尽可能多的连接器，这些连接器与这个容器是相关的。清单14.6是Service的接口。

package org.apache.catalina;


public interface Service {

         public Container getContainer();
         public void setContainer(Container container);
         public String getInfo();
         public String getName();
         public void setName(String name);
         public Server getServer();
         public void setServer(Server server);
         public void addConnector(Connector connector);
         public Connector[] findConnectors();
         public void removeConnector(Connector connector);
         public void initialize() throws LifecycleException;
}
 

StandardService

org.apache.catalina.core.StandardService类是Service的标准实现。这个类的initialize方法初始化了添加到这个Service的所有的连接器。这个类同时也实现了org.apache.catalian.Lifecycle接口。它的start方法开启了容器和所有的连接器。

Container和Connector(s)

一个StandardService实例包含了两类组件：一个容器和一个或者多个连接器。拥有更多的的连接器使得Tomcat能够支持更多的协议。一个连接器可以服务HTTP请求则另一个连接器可以支持HTTPS请求。

StandardService类使用container变量，一个对象的引用作为Container的实例，以conncetors数组代表所有的连接器。

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

使用setContainer方法使一个container与一个Service关联。代码清单如下：

public void setContainer(Container container) {

	Container oldContainer = this.container;

	if ((oldContainer != null) && (oldContainer instanceof Engine))

		instanceof Engine)) ((Engine) oldContainer).setService(null);

	this.container = container;

	if ((this.container != null) && (this.container instanceof Engine))

	  ((Engine) this.container).setService(this);

	if (started && (this.container != null) 

	    &&(this.container instanceof Lifecycle)) {

		try {

			((Lifecycle) this.container).start();

		}catch (LifecycleException e) {

			;

		}

	}

	synchronized (connectors) {

		for (int i = 0; i < connectors.length; i++)

			connectors[i].setContainer(this.container);

	}

	if (started && (oldContainer != null) &&

	    (oldContainer instanceof Lifecycle)) {
	    	try {

			((Lifecycle) oldContainer).stop();

		}

		catch (LifecycleException e) {

			;

		}

	}

	// Report this property change to interested listeners

	support.firePropertyChange("container", oldContainer,

		this.container);
}

与这个Service相关联的container通过setContainer方法传递，那么这个Service相关联的每个connector对象在container与每个connector之间建立了一种关联。

为了给Service对象添加一个连接器，使用addConnector方法。为了移除一个连接器，调用removeConnector方法。addConnector和removeCon方法的代码清单如下：

public void addConnector(Connector connector) {

  synchronized (connectors) {

	connector.setContainer(this.container);

	connector.setService(this);

	Connector results[] = new Connector[connectors.length + 1];

	System.arraycopy(connectors, 0, results, 0, connectors.length);

	results[connectors.length] = connector;

	connectors = results;

	if (initialized) {

	    try {

		connector.initialize();

		}

	    catch (LifecycleException e) {

		e.printStackTrace(System.err);

		}

	}

	if (started && (connector instanceof Lifecycle)) {

	     try{

		((Lifecycle) connector).start();

		}

		catch (LifecycleException e) {

			;

		}

	}

	// Report this property change to interested listeners

	support.firePropertyChange("connector", null, connector);

  }

}

public void removeConnector(Connector connector) {

   synchronized (connectors) {

	int j = -1;

	for (int i = 0; i < connectors.length; i++) {

		if (connector == connectors [i]) {

		j = i;

		break;

		}

	}

	if (j < 0)

		return;

	if (started && (connectors[j] instanceof Lifecycle)) {

		try {

			((Lifecycle) connectors[j]).stop();

		}

		catch (LifecycleException e) {

			;

		}

	}

	connectors[j].setContainer(null);

	connector.setService(null);

	int k = 0;

	Connector results[] = new Connector[connectors.length - 1];

	for (int i = 0; i < connectors.length; i++) {

		if (i != j)

			results[k++] = connectors[i];

	}

	connectors = results;

	// Report this property change to interested listeners

	support.firePropertyChange("connector", connector, null);

    }

}

addConnector方法初始化和开启添加的连接器。

Lifecycle方法

生命周期方法是从Lifecycle接口中继承的start方法和stop方法，外加initialize方法。initialize方法调用了与这个Service相关的所有connector的initialize方法。这个方法的代码清单如下：

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

	initialized = true;

	// Initialize our defined Connectors

	synchronized (connectors) {

		for (int i = 0; i < connectors.length; i++) {

			connectors[i].initialize();

		}

	}
}

start方法启动了关联的container和添加到这个Service的connector。代码清单如下：

public void start() throws LifecycleException {
        // Validate and update our current component state

	if (started) {

		throw new LifecycleException

			(sm.getString("standardService.start.started"));

	}

	// Notify our interested LifecycleListeners

	lifecycle.fireLifecycleEvent(BEFORE_START_EVENT, null);

	System.out.println

		(sm.getString("standardService.start.name", this.name));

	lifecycle.fireLifecycleEvent(START_EVENT, null);

	started = true;

	// Start our defined Container first

	if (container != null) {

		synchronized (container) {

			if (container instanceof Lifecycle) {

				((Lifecycle) container).start();

			}

		}

	}

	// Start our defined Connectors second

	synchronized (connectors) {

		for (int i = 0; i < connectors.length; i++) {

			if (connectors[i] instanceof Lifecycle)

				((Lifecycle) connectors[i]).start();

		}

	}

	// Notify our interested LifecycleListeners

	lifecycle.fireLifecycleEvent(AFTER_START_EVENT, null);
}

stop方法停止了相关联的container和所有的连接器。其代码清单如下：

public void stop() throws LifecycleException {
	// Validate and update our current component state

	if (!started) {

		throw new LifecycleException

			(sm.getString("standardService.stop.notStarted"));

	}

	// Notify our interested LifecycleListeners

	lifecycle.fireLifecycleEvent(BEFORE_STOP_EVENT, null);

	lifecycle.fireLifecycleEvent(STOP_EVENT, null);

	System.out.println

		(sm.getString("standardService.stop.name", this.name));

	started = false;

	// Stop our defined Connectors first

	synchronized (connectors) {

		for (int i = 0; i < connectors.length; i++) {

			if (connectors[i] instanceof Lifecycle)

				((Lifecycle) connectors[i]).stop();

		}

	}

	// Stop our defined Container second

	if (container != null) {

		synchronized (container) {

			if (container instanceof Lifecycle) {

				((Lifecycle) container).stop();

			}

		}

	}

	// Notify our interested LifecycleListeners

	lifecycle.fireLifecycleEvent(AFTER_STOP_EVENT, null);
}