《how tomcat work》 搬运工 Chapter 6:Lifecycle & Chapter 7:Logger &Chapter 8: Loader

Chapter 6

在tomcat 中有很多的组件，这些组件会启动，会在关闭的时候做一些清除的工作，所以就需要Lifecycle这个组件来扩展。

Lifecycle主要包括三部分

1、The Lifecycle Interface

要使用lifecycle的组件，需要实现这个接口，这样就可以开启或关闭lifecycle,以及lifecycleListener的添加和修改与查找

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

 

2、The LifecycleListener Interface 和 LifecycleEvent

LifecycleListener就是出来事件的，把event传进来然后处理

 

public final class LifecycleEvent extends EventObject { 
    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; 
    } 
    private Object data = null; 
    private Lifecycle lifecycle = null; 
    private String type = null; 
    public Object getData() { 
        return (this.data); 
    } 
    public Lifecycle getLifecycle() { 
        return (this.lifecycle); 
    }
    public String getType() { 
        return (this.type); 
    } 
}    

 

 

 

 

public interface LifecycleListener { 
    public void lifecycleEvent(LifecycleEvent event); 
}

 

 

3、The LifecycleSupport Class

Catalina为实现了Lifecycle的组件能够更加简单实现Lifecycle，就弄出了这个类，这个就将添加LifecycleListener,删除LifecycleListener,存储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) { 
        synchronized (listeners) { 
            int n = -1; 
            for (int i = 0; i < listeners.length; i++) { 
                if (listeners[i] == listener) { 
                    n = i; 
                    break; 
                } 
            } 
            if (n < 0) return; 
            LifecycleListener results[] = new LifecycleListener[listeners.length - 1];
            int j = 0; 
            for (int i = 0; i < listeners.length; i++) { 
                if(i != n) results[j++] = listeners[i]; 
            } 
            listeners = results; 
        } 
    } 
}    

 

 

在container中的实际用法

首先在context中implements Lifecycle,再添加一个LifecycleSupport的实例lifecycle,和一个addLifecycleListener方法添加LifecycleListener，当然还有其他方法

public class SimpleContext implements Context, Pipeline, Lifecycle {
    ...
    ...
    ...
    protected LifecycleSupport lifecycle = new LifecycleSupport(this);
    ...
    ...

　　　 public void addLifecycleListener(LifecycleListener listener) {
　　    　　lifecycle.addLifecycleListener(listener);
　　　 }

}

 

下面的方法是simpleContext的start()方法，通过start()来触发lifecycle的lifecycleListener，还有包括loader,context 的children的start()

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

    // Notify our interested LifecycleListeners
    lifecycle.fireLifecycleEvent(AFTER_START_EVENT, null);
  }

 

Chapter 7:Logger

Logger就负责了日志的记录,在how tomcat work里介绍了很多，真正用到的地方是

System.setProperty("catalina.base", System.getProperty("user.dir")); 
FileLogger logger = new FileLogger(); 
logger.setPrefix("FileLog_"); 
logger.setSuffix(".txt"); 
logger.setTimestamp(true); 
logger.setDirectory("webroot"); 
context.setLogger(logger);

 

Chapter 8: Loader

Loader是java中一个重要的组成部分。

在Tomcat中，来加载类的是WebappLoader Class。

这个能控制好类的加载权限，和缓存加载成功的类，以及缓存加载失败的类。

    // here is our loader
    Loader loader = new WebappLoader();
    // associate the loader with the Context
    context.setLoader(loader);