在前面的文章中，已经学会了如何通过实例化一个连接器和容器来获得一个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."
);
}
}
}
---------------------------------------------------------------------------
本系列How Tomcat Works系本人原创
转载请注明出处 博客园 刺猬的温驯
本人邮箱： chenying998179 # 163.com （ #改为@ ）
