我觉得这一章叫tomcat中的观察者模式,比较好!
首先,不要看本章,请查看一下关于观察者模式的资料比较好。
推荐以下知识点
基础篇
设计模式之禅----观察者模式
大家可以找到pdf阅读一下
另外本人的博客中也有一篇<<谈谈观察者模式 >> 很久之前写的,是阅读上书观察者模式时做的笔记,写的实在不敢恭维,如果找不到书,倒是可以看看鄙人的博客。
http://www.cnblogs.com/wangjq/archive/2012/07/12/2587966.html
上面的这个博客,让具体的观察者和被观察者耦合,大家可以看看。
进阶篇
http://blog.csdn.net/lovelion/article/details/7720232
看了上面的一个pdf两个博客,我就认为大家理解了观察者模式,现在咱们开始说tomcat;
第六章的题目叫做生命周期,说的内容就是如何在上级容器启动或者关闭的时候,可以自动启动或关闭它的组件。
其实更准确的说是,在上级容器启动的时候如何通知别的容器(因为要实现父容器启动,子组件也启动,很简单,循环获得所有子组件,调用start方法即可)
几个类和接口
Lifecycle接口
我们既然说到生命周期,说到事件,那总得有个接口来表示这些事件吧
package org.apache.catalina;
public interface Lifecycle {
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 void addLifecycleListener(LifecycleListener listener);
public LifecycleListener[] findLifecycleListeners();
public void removeLifecycleListener(LifecycleListener listener);
public void start() throws LifecycleException;
public void stop() throws LifecycleException;
}
一共六个事件类型开始,结束等等。下面的几个方法见名知意不再赘述。
LifeEvent类
package org.apache.catalina;
import java.util.EventObject;
public final class LifecycleEvent extends EventObject {
private Object data = null;
private Lifecycle lifecycle = null;
private String type = null;
public LifecycleEvent(Lifecycle lifecycle, String type) {
this(lifecycle, type, null);
}
public LifecycleEvent(Lifecycle lifecycle, String type, Object data) {
super(lifecycle);
this.lifecycle = lifecycle;
this.type = type;
this.data = data;
}
public Object getData() {
return (this.data);
}
public Lifecycle getLifecycle() {
return (this.lifecycle);
}
public String getType() {
return (this.type);
}<pre name="code" class="java">
}
这个Event很简单,就是哪个实现了Lifecycle接口的对象在某个时间发生了某件事。
LifecycleListener接口
<pre name="code" class="java">package org.apache.catalina;
import java.util.EventObject;
public interface LifecycleListener {
public void lifecycleEvent(LifecycleEvent event);
}
这就相当于上面几篇博客中的Observiser接口,lifecycleEvent就是update方法,不同的是前面几篇博客中,实现LifecycleListener接口的对象就是监听的实体,这里不是*************
LifecycleSupport类
一个对象,可以给自己增加多个监听器,这个多个监听器可以组成一个数组或其他类似的结构中,这个功能就由LifecycleSupport类来实现。
package org.apache.catalina.util;
import org.apache.catalina.Lifecycle;
import org.apache.catalina.LifecycleEvent;
import org.apache.catalina.LifecycleListener;
public final class LifecycleSupport {
public LifecycleSupport(Lifecycle lifecycle) {
super();
this.lifecycle = lifecycle;
}
private Lifecycle lifecycle = null;
private LifecycleListener listeners[] = new LifecycleListener[0];
public void addLifecycleListener(LifecycleListener listener) {
synchronized (listeners) {
LifecycleListener results[] =new LifecycleListener[listeners.length + 1];
for (int i = 0; i < listeners.length; i++)
results[i] = listeners[i];
results[listeners.length] = listener;
listeners = results;
}
}
public LifecycleListener[] findLifecycleListeners() {
return listeners;
}
public void fireLifecycleEvent(String type, Object data) {
LifecycleEvent event = new LifecycleEvent(lifecycle, type, data);
LifecycleListener interested[] = null;
synchronized (listeners) {
interested = (LifecycleListener[]) listeners.clone();
}
for (int i = 0; i < interested.length; i++)
interested[i].lifecycleEvent(event);
}
public void removeLifecycleListener(LifecycleListener listener) {
..省略代码
}
}
我们看看那个fireLifecycleEvent(String type, Object data),它就是上面几篇博客中Subjet中的notify方法,依次调用每个listener的lifeEvent()方法(就是上面说的update方法)。
ok,我们看应用程序
应用程序
xml图如下:
看看SimpleContext与LifecycleSuppot,它们是使用的关系,SimpleContext中有一个LifecycleSuppot,
代码如下
protected LifecycleSupport lifecycle = new LifecycleSupport(this);
其实每一个实现了Lifecycle接口的组件,都可以有一个LifecycleSupport。
另外,还有一个布尔型变量started,来知识容器是否已经启动。
现在我们看看SimpleContext中实现Lifecycle接口中的方法。
public synchronized void start() throws LifecycleException {
if (started)
throw new LifecycleException("SimpleContext has already started");
// Notify our interested LifecycleListeners
lifecycle.fireLifecycleEvent(BEFORE_START_EVENT, null);
started = true;
try {
// Start our subordinate components, if any
if ((loader != null) && (loader instanceof Lifecycle))
((Lifecycle) loader).start();
// Start our child containers, if any
Container children[] = findChildren();
for (int i = 0; i < children.length; i++) {
if (children[i] instanceof Lifecycle)
((Lifecycle) children[i]).start();
}
// Start the Valves in our pipeline (including the basic),
// if any
if (pipeline instanceof Lifecycle)
((Lifecycle) pipeline).start();
// Notify our interested LifecycleListeners
lifecycle.fireLifecycleEvent(START_EVENT, null);
}
catch (Exception e) {
e.printStackTrace();
}
本节的启动程序与上一节没有什么区别,除了
LifecycleListener listener = new SimpleContextLifecycleListener();
((Lifecycle) context).addLifecycleListener(listener);
context的addLifecycleListener方法,就是把监听器(就是上面说的李斯)放到context中的LifecycleSuppour的数组中去!
我们再看看SimpleContextLifecycleListener
public class SimpleContextLifecycleListener implements LifecycleListener {
@SuppressWarnings("unused")
public void lifecycleEvent(LifecycleEvent event) {
Lifecycle lifecycle = event.getLifecycle();
System.out.println("SimpleContextLifecycleListener's event " +event.getType().toString());
if (Lifecycle.START_EVENT.equals(event.getType())) {
System.out.println("Starting context.");
}
else if (Lifecycle.STOP_EVENT.equals(event.getType())) {
System.out.println("Stopping context.");
}
}
}
不用解释了吧。
其实在本节程序里,我们只是给SimpleContext加了一个监听器,换句话说,SimpleWrapper中的start方法中虽然也有lifecycle.fireLifecycleEvent(START_EVENT, null)方法,但是LifecycelSupport中的数组中并没有监听器,也就没有什么通知的了。
最后我们运行起来看看
HttpConnector Opening server socket on all host IP addresses
HttpConnector[8080] Starting background thread
SimpleContextLifecycleListener's event before_start
Starting SimpleLoader
Starting Wrapper Modern
Starting Wrapper Primitive
SimpleContextLifecycleListener's event start
Starting context.
SimpleContextLifecycleListener's event after_start
Wrapper,Loader的start方法只是在屏幕中打印出信息,并没有再次触发什么事件。
一点感觉
总感觉这一章怪怪的,要说是启动子容器,直接循环取得子容器,然后调用start方法即可;观察者模式在本节的作用就是打印出
SimpleContextLifecycleListener's event before_start
SimpleContextLifecycleListener's event start
SimpleContextLifecycleListener's event after_start
这三句话而已,似乎没有什么大的作用。
后来我仔细想想观察者模式,它就是一个通知的作用,通知所有关注自己的对象,只有那观察者知道自己观察的对象有了状态变化之后干什么,就不是观察者模式考虑的是事了,观察者模式只管通知!
在本节,观察者只是打印出一句话,所以显得比较简单而已,当然要想复杂改LifecycleListener类的lifecycleEvent方法即可。