在前面的文章中,已经学会了如何通过实例化一个连接器和容器来获得一个servlet容器,并将连接器和容器相关联;但在前面的文章中只有一个连接器可用,该连接器服务8080端口上的HTTP请求,无法添加另一个连接器来服务诸如HTTPS之类的其他请求;此外,在前面的文章中的应用程序中有些缺憾,即缺少一种启动/关闭servlet容器的机制。

org.apache.catalina.Server接口的实例表示Catalina的整个servlet引擎,囊括了所有的组件;它使用一个优雅的方式来启动/关闭整个系统,不需要再对连接器和容器分别启动/关闭(当启动Server组件时,它会启动其中所有的组件,然后它就无限期地等待关闭命令;如果想要关闭系统,可以向指定端口发送一条关闭命令,Server组件接收到关闭命令后,就会关闭其中所有的组件)。

Server组件使用了另一个组件(即Service组件)来包含其他组件,如一个容器组件和一个或多个连接器组件。

下面是Server接口的定义



public interface Server {

public String getInfo();

public NamingResources getGlobalNamingResources();

public void setGlobalNamingResources(NamingResources globalNamingResources);

public int getPort();

public void setPort(int port);

public String getShutdown();

public void setShutdown(String shutdown);

public void addService(Service service);

public void await();

public Service findService(String name);

public Service[] findServices();

public void removeService(Service service);

public void initialize() throws LifecycleException;
}


shutdown属性保存了必须发送给Server实例用来关闭整个系统的关闭命令,port属性定义了Server组件会从哪个端口获取关闭命令,可以调用addService()方法为Server组件添加Service组件,或通过removeService()方法删除某个Service组件,findService()方法将会返回添加到该Server组件中的所有Service组件,initialize()方法包含在系统启动前要执行的一些代码

 org.apache.catalina.core.StandardServer类是Server接口的标准实现,介绍这个类是因为我们对其中的关闭机制比较感兴趣,而这也是这个类中最重要的特性;该类的许多方法都与新server.xml文件中的服务器配置的存储相关,但这并不是本文的重点。

一个Server组件可以有多个Service组件,StandardServer类提供了addService()方法、 removeService()方法和findServices()方法的实现

StandardServer类有四个与生命周期相关的方法,分别是initialize()方法、 start()方法、 stop()方法和await()方法,就像其他组件一样,可以初始化并启动Server组件,然后调用await()方法及stop()方法。调用await()方法后会一直阻塞住,直到它总8085端口上接收到关闭命令。当await()方法返回时,会运行stop()方法来关闭其下的所有子组件。

Server实例的initialize()方法用于初始化添加到其中的Service组件,下面是tomcat4中StandardServer类中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();
}
}


start()方法用于启动Server组件,在StandardServer类的start()方法的实现中,它会启动其所有的Service组件,这些Service组件它们逐个启动所有其他的组件,如连接器组件和servlet容器。



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
lifecycle.fireLifecycleEvent(BEFORE_START_EVENT, null);

lifecycle.fireLifecycleEvent(START_EVENT, null);
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
lifecycle.fireLifecycleEvent(AFTER_START_EVENT, null);

}


stop()方法用于关闭Server组件



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
lifecycle.fireLifecycleEvent(BEFORE_STOP_EVENT, null);

lifecycle.fireLifecycleEvent(STOP_EVENT, null);
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
lifecycle.fireLifecycleEvent(AFTER_STOP_EVENT, null);

}


await()方法负责停止整个tomcat部署的机制



/**
* Wait until a proper shutdown command is received, then return.
*/
public void await() {

// Set up a server socket to wait on
ServerSocket serverSocket = null;
try {
serverSocket =
new ServerSocket(port, 1,
InetAddress.getByName("127.0.0.1"));
} catch (IOException e) {
System.err.println("StandardServer.await: create[" + port
+ "]: " + e);
e.printStackTrace();
System.exit(1);
}

// Loop waiting for a connection and a valid command
while (true) {

// Wait for the next connection
Socket socket = null;
InputStream stream = null;
try {
socket = serverSocket.accept();
socket.setSoTimeout(10 * 1000); // Ten seconds
stream = socket.getInputStream();
} catch (AccessControlException ace) {
System.err.println("StandardServer.accept security exception: "
+ ace.getMessage());
continue;
} catch (IOException e) {
System.err.println("StandardServer.await: accept: " + e);
e.printStackTrace();
System.exit(1);
}

// Read a set of characters from the socket
StringBuffer command = new StringBuffer();
int expected = 1024; // Cut off to avoid DoS attack
while (expected < shutdown.length()) {
if (random == null)
random = new Random(System.currentTimeMillis());
expected += (random.nextInt() % 1024);
}
while (expected > 0) {
int ch = -1;
try {
ch = stream.read();
} catch (IOException e) {
System.err.println("StandardServer.await: read: " + e);
e.printStackTrace();
ch = -1;
}
if (ch < 32) // Control character or EOF terminates loop
break;
command.append((char) ch);
expected--;
}

// Close the socket now that we are done with it
try {
socket.close();
} catch (IOException e) {
;
}

// Match against our command string
boolean match = command.toString().equals(shutdown);
if (match) {
break;
} else
System.err.println("StandardServer.await: Invalid command '" +
command.toString() + "' received");

}

// Close the server socket and return
try {
serverSocket.close();
} catch (IOException e) {
;
}

}


await()方法创建一个ServerSocket对象,监听8085端口,并在while循环中调用它的accept()方法,挡在指定端口上接收到消息时,才会从accept()方法中返回,然后将接收到的消息与关闭命令的字符串相比较,相同的话就跳出while循环,关闭ServerSocket,否则会再次循环,继续等待消息。

Service组件是org.apache.catalina.Service接口的实例,一个Service组件可以有一个servlet容器和多个连接器实例,可以自由地把连接器实例添加到Service组件中,所有的连接器都会与该servlet容器相关联

下面是Service接口的定义



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;
}


org.apache.catalina.core.StandardService类是Service接口的标准实现,StandardService类的initialize()方法用于初始化添加到其中的所有连接器;此外,还实现了org.apache.catalina.Lifecycle接口,它的start()方法用于启动servlet容器和所有连接器

StandardService实例中有两种组件,分别是连接器和servlet容器,其中servlet容器只有一个,而连接器则可以有多个,多个连接器使tomcat可以为多种不同的请求协议提供服务。例如,一个连接器处理HTTP请求,而另一个可以处理HTTPS请求。

StandardService类使用变量container来指向一个Container接口的实例,使用数组connectors来保存所有连接器的引用

private Container container = null;

private Connector connectors[] = new Connector[0];

需要调用setContainer()方法将servlet容器与Service组件相关联:



public void setContainer(Container container) {

Container oldContainer = this.container;
if ((oldContainer != null) && (oldContainer 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组件相关联的servlet容器的实例将被传给每个连接器对象的setContainer()方法,这样在Service组件中就可以形成每个连接器和servlet容器之间的关联关系。

可以调用addConnector()方法将连接器添加到Service组件中,调用removeConnector()方法将某个连接器移除



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);
}

}


与生命周期相关的方法包括从Lifecycle接口中实现的start()方法和stop()方法,在加上initialize()方法,其中initialize()方法会调用该Service组件中所有连接器的上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()方法负责启动被添加到该Service组件中的连接器和servlet容器:



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()方法用于关闭与该Service组件相关联的servlet容器和所有连接器



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);

}


在前面文章的应用程序中,通过按某个键或强制中断的方式关闭servlet容器,Stopper类提供了一种更优雅的方式来关闭Catalina服务器;此外,它也保证了所有的生命周期组件的stop()方法都能够调用。



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.");
}
}
}