tomcat源码-监听器设计模式

没有demo的设计模式博客没有灵魂：https://gitee.com/gudaichaoren/lifecyclelistener.git

在tomcat中容器组件都要经历一套生命周期

NEW(创建)-->INITIALIZED(初始化)-->.....-->DESTROYED(销毁)，而周期状态变更系统都要做相应的处理，这就可以使用监听器去监听这个动作，从而做出相应处理。

重要组件：

1.Lifecycle：生命周期的接口

2.LifecycleBase：实现Lifecycle接口，抽取通用方法与通用变量避免重复代码

3.LifecycleListener：监听器，根据对应的事件做相应处理

4.LifecycleEvent：事件，触发监听器工作的条件

这里用一个简单例子来阐述：气象站，对下雨进行监测，当下雨时监听器报'开始下雨，记得带伞',停雨时监听器报'停雨了，happy'。

代码如下

定义生命周期接口

/**
 * 生命周期接口
 */
public interface Lifecycle {
    public static final String START_EVENT = "start";
    public static final String STOP_EVENT = "stop";
    /**
     * 增加监听器
     * @param listener
     */
    void addLifecycleListener(LifecycleListener listener);
    /**
     * 生命周期开始
     */
    void start();
    /**
     * 生命周期结束
     */
    void stop();
}

生命周期基类

public abstract class LifecycleBase implements Lifecycle {

    private final List<LifecycleListener> lifecycleListeners = new CopyOnWriteArrayList<>();

    @Override
    public void addLifecycleListener(LifecycleListener listener) {
        lifecycleListeners.add(listener);
    }

    /**
     * 触发生命周期事件
     * @param type
     * @param data
     */
    protected void fireLifecycleEvent(String type, Object data) {
        LifecycleEvent event = new LifecycleEvent(this, type, data);
        for (LifecycleListener listener : lifecycleListeners) {
            listener.lifecycleEvent(event);
        }
    }
}

事件基类

public final class LifecycleEvent {

    private final Lifecycle lifecycle;
    private final Object data;
    private final String type;

    public LifecycleEvent(Lifecycle lifecycle, String type, Object data) {
        this.lifecycle = lifecycle;
        this.data = data;
        this.type = type;
    }

    public Lifecycle getLifecycle() {
        return lifecycle;
    }

    public Object getData() {
        return data;
    }

    public String getType() {
        return type;
    }
}

监听器接口

public interface LifecycleListener {
    /**
     * 监听器执行方法
     * @param event
     */
    void lifecycleEvent(LifecycleEvent event);
}

上面核心类有了，下面看看具体实现

监听器具体实现

public class RainListener implements LifecycleListener {
    @Override
    public void lifecycleEvent(LifecycleEvent event) {
        if (Lifecycle.START_EVENT.equals(event.getType())) {
            System.out.println("开始下雨，记得带伞");
        } else if (Lifecycle.STOP_EVENT.equals(event.getType())) {
            System.out.println("停雨了，happy去");
        }
    }
}

气象站对象，实现LifecycleBase拥有了生命周期

public class RainWeatherStation extends LifecycleBase {

    @Override
    public void start() {
        //监听到下雨了
        super.fireLifecycleEvent(Lifecycle.START_EVENT,null);
    }

    @Override
    public void stop() {
        //监听到停雨了
        super.fireLifecycleEvent(Lifecycle.STOP_EVENT,null);
    }
}

测试类

public class Test {
    public static void main(String[] args) {
        RainWeatherStation rainWeatherStation = new RainWeatherStation();
        //增加监听器
        rainWeatherStation.addLifecycleListener(new RainListener());
        //下雨了
        rainWeatherStation.start();
        System.out.println("---雨在哗啦啦下---");
        //停雨了
        rainWeatherStation.stop();
    }
}

测试结果

开始下雨，记得带伞
---雨在哗啦啦下---
停雨了，happy去